1 use std::iter::ExactSizeIterator;
4 use rustc_ast::ast::{self, FnRetTy, Mutability, Term};
6 use rustc_span::{symbol::kw, BytePos, Pos, Span};
8 use crate::comment::{combine_strs_with_missing_comments, contains_comment};
9 use crate::config::lists::*;
10 use crate::config::{IndentStyle, TypeDensity, Version};
12 format_expr, rewrite_assign_rhs, rewrite_call, rewrite_tuple, rewrite_unary_prefix, ExprType,
16 definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
18 use crate::macros::{rewrite_macro, MacroPosition};
20 use crate::pairs::{rewrite_pair, PairParts};
21 use crate::rewrite::{Rewrite, RewriteContext};
22 use crate::shape::Shape;
23 use crate::source_map::SpanUtils;
24 use crate::spanned::Spanned;
26 colon_spaces, extra_offset, first_line_width, format_extern, format_mutability,
27 last_line_extendable, last_line_width, mk_sp, rewrite_ident,
30 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
31 pub(crate) enum PathContext {
37 // Does not wrap on simple segments.
38 pub(crate) fn rewrite_path(
39 context: &RewriteContext<'_>,
40 path_context: PathContext,
41 qself: Option<&ast::QSelf>,
45 let skip_count = qself.map_or(0, |x| x.position);
47 let mut result = if path.is_global() && qself.is_none() && path_context != PathContext::Import {
53 let mut span_lo = path.span.lo();
55 if let Some(qself) = qself {
58 let fmt_ty = qself.ty.rewrite(context, shape)?;
59 result.push_str(&fmt_ty);
62 result.push_str(" as ");
63 if path.is_global() && path_context != PathContext::Import {
64 result.push_str("::");
68 let shape = shape.sub_width(3)?;
70 result = rewrite_path_segments(
73 path.segments.iter().take(skip_count),
81 result.push_str(">::");
82 span_lo = qself.ty.span.hi() + BytePos(1);
85 rewrite_path_segments(
88 path.segments.iter().skip(skip_count),
96 fn rewrite_path_segments<'a, I>(
97 path_context: PathContext,
100 mut span_lo: BytePos,
102 context: &RewriteContext<'_>,
106 I: Iterator<Item = &'a ast::PathSegment>,
108 let mut first = true;
109 let shape = shape.visual_indent(0);
111 for segment in iter {
112 // Indicates a global path, shouldn't be rendered.
113 if segment.ident.name == kw::PathRoot {
119 buffer.push_str("::");
122 let extra_offset = extra_offset(&buffer, shape);
123 let new_shape = shape.shrink_left(extra_offset)?;
124 let segment_string = rewrite_segment(
133 buffer.push_str(&segment_string);
140 pub(crate) enum SegmentParam<'a> {
141 Const(&'a ast::AnonConst),
142 LifeTime(&'a ast::Lifetime),
144 Binding(&'a ast::AssocConstraint),
147 impl<'a> SegmentParam<'a> {
148 fn from_generic_arg(arg: &ast::GenericArg) -> SegmentParam<'_> {
150 ast::GenericArg::Lifetime(ref lt) => SegmentParam::LifeTime(lt),
151 ast::GenericArg::Type(ref ty) => SegmentParam::Type(ty),
152 ast::GenericArg::Const(const_) => SegmentParam::Const(const_),
157 impl<'a> Spanned for SegmentParam<'a> {
158 fn span(&self) -> Span {
160 SegmentParam::Const(const_) => const_.value.span,
161 SegmentParam::LifeTime(lt) => lt.ident.span,
162 SegmentParam::Type(ty) => ty.span,
163 SegmentParam::Binding(binding) => binding.span,
168 impl<'a> Rewrite for SegmentParam<'a> {
169 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
171 SegmentParam::Const(const_) => const_.rewrite(context, shape),
172 SegmentParam::LifeTime(lt) => lt.rewrite(context, shape),
173 SegmentParam::Type(ty) => ty.rewrite(context, shape),
174 SegmentParam::Binding(atc) => atc.rewrite(context, shape),
179 impl Rewrite for ast::AssocConstraint {
180 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
181 use ast::AssocConstraintKind::{Bound, Equality};
183 let mut result = String::with_capacity(128);
184 result.push_str(rewrite_ident(context, self.ident));
186 if let Some(ref gen_args) = self.gen_args {
187 let budget = shape.width.checked_sub(result.len())?;
188 let shape = Shape::legacy(budget, shape.indent + result.len());
189 let gen_str = rewrite_generic_args(gen_args, context, shape, gen_args.span())?;
190 result.push_str(&gen_str);
193 let infix = match (&self.kind, context.config.type_punctuation_density()) {
194 (Bound { .. }, _) => ": ",
195 (Equality { .. }, TypeDensity::Wide) => " = ",
196 (Equality { .. }, TypeDensity::Compressed) => "=",
198 result.push_str(infix);
200 let budget = shape.width.checked_sub(result.len())?;
201 let shape = Shape::legacy(budget, shape.indent + result.len());
202 let rewrite = self.kind.rewrite(context, shape)?;
203 result.push_str(&rewrite);
209 impl Rewrite for ast::AssocConstraintKind {
210 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
212 ast::AssocConstraintKind::Equality { term } => match term {
213 Term::Ty(ty) => ty.rewrite(context, shape),
214 Term::Const(c) => c.rewrite(context, shape),
216 ast::AssocConstraintKind::Bound { bounds } => bounds.rewrite(context, shape),
221 // Formats a path segment. There are some hacks involved to correctly determine
222 // the segment's associated span since it's not part of the AST.
224 // The span_lo is assumed to be greater than the end of any previous segment's
225 // parameters and lesser or equal than the start of current segment.
227 // span_hi is assumed equal to the end of the entire path.
229 // When the segment contains a positive number of parameters, we update span_lo
230 // so that invariants described above will hold for the next segment.
232 path_context: PathContext,
233 segment: &ast::PathSegment,
234 span_lo: &mut BytePos,
236 context: &RewriteContext<'_>,
238 ) -> Option<String> {
239 let mut result = String::with_capacity(128);
240 result.push_str(rewrite_ident(context, segment.ident));
242 let ident_len = result.len();
243 let shape = if context.use_block_indent() {
244 shape.offset_left(ident_len)?
246 shape.shrink_left(ident_len)?
249 if let Some(ref args) = segment.args {
250 let generics_str = rewrite_generic_args(args, context, shape, mk_sp(*span_lo, span_hi))?;
252 ast::GenericArgs::AngleBracketed(ref data) if !data.args.is_empty() => {
253 // HACK: squeeze out the span between the identifier and the parameters.
254 // The hack is required so that we don't remove the separator inside macro calls.
255 // This does not work in the presence of comment, hoping that people are
256 // sane about where to put their comment.
257 let separator_snippet = context
258 .snippet(mk_sp(segment.ident.span.hi(), data.span.lo()))
260 let force_separator = context.inside_macro() && separator_snippet.starts_with("::");
261 let separator = if path_context == PathContext::Expr || force_separator {
266 result.push_str(separator);
268 // Update position of last bracket.
271 .span_after(mk_sp(*span_lo, span_hi), "<");
275 result.push_str(&generics_str)
281 fn format_function_type<'a, I>(
286 context: &RewriteContext<'_>,
290 I: ExactSizeIterator,
291 <I as Iterator>::Item: Deref,
292 <I::Item as Deref>::Target: Rewrite + Spanned + 'a,
294 debug!("format_function_type {:#?}", shape);
296 let ty_shape = match context.config.indent_style() {
298 IndentStyle::Block => shape.offset_left(4)?,
299 IndentStyle::Visual => shape.block_left(4)?,
301 let output = match *output {
302 FnRetTy::Ty(ref ty) => {
303 let type_str = ty.rewrite(context, ty_shape)?;
304 format!(" -> {}", type_str)
306 FnRetTy::Default(..) => String::new(),
309 let list_shape = if context.use_block_indent() {
311 shape.block().indent.block_indent(context.config),
316 let budget = shape.width.checked_sub(2)?;
318 let offset = shape.indent + 1;
319 Shape::legacy(budget, offset)
322 let is_inputs_empty = inputs.len() == 0;
323 let list_lo = context.snippet_provider.span_after(span, "(");
324 let (list_str, tactic) = if is_inputs_empty {
325 let tactic = get_tactics(&[], &output, shape);
326 let list_hi = context.snippet_provider.span_before(span, ")");
327 let comment = context
329 .span_to_snippet(mk_sp(list_lo, list_hi))?
331 let comment = if comment.starts_with("//") {
334 &list_shape.indent.to_string_with_newline(context.config),
336 &shape.block().indent.to_string_with_newline(context.config)
343 let items = itemize_list(
344 context.snippet_provider,
348 |arg| arg.span().lo(),
349 |arg| arg.span().hi(),
350 |arg| arg.rewrite(context, list_shape),
356 let item_vec: Vec<_> = items.collect();
357 let tactic = get_tactics(&item_vec, &output, shape);
358 let trailing_separator = if !context.use_block_indent() || variadic {
359 SeparatorTactic::Never
361 context.config.trailing_comma()
364 let fmt = ListFormatting::new(list_shape, context.config)
366 .trailing_separator(trailing_separator)
367 .ends_with_newline(tactic.ends_with_newline(context.config.indent_style()))
368 .preserve_newline(true);
369 (write_list(&item_vec, &fmt)?, tactic)
372 let args = if tactic == DefinitiveListTactic::Horizontal
373 || !context.use_block_indent()
376 format!("({})", list_str)
380 list_shape.indent.to_string_with_newline(context.config),
382 shape.block().indent.to_string_with_newline(context.config),
385 if output.is_empty() || last_line_width(&args) + first_line_width(&output) <= shape.width {
386 Some(format!("{}{}", args, output))
391 list_shape.indent.to_string(context.config),
397 fn type_bound_colon(context: &RewriteContext<'_>) -> &'static str {
398 colon_spaces(context.config)
401 // If the return type is multi-lined, then force to use multiple lines for
402 // arguments as well.
403 fn get_tactics(item_vec: &[ListItem], output: &str, shape: Shape) -> DefinitiveListTactic {
404 if output.contains('\n') {
405 DefinitiveListTactic::Vertical
409 ListTactic::HorizontalVertical,
411 // 2 is for the case of ',\n'
412 shape.width.saturating_sub(2 + output.len()),
417 impl Rewrite for ast::WherePredicate {
418 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
419 // FIXME: dead spans?
420 let result = match *self {
421 ast::WherePredicate::BoundPredicate(ast::WhereBoundPredicate {
422 ref bound_generic_params,
427 let type_str = bounded_ty.rewrite(context, shape)?;
428 let colon = type_bound_colon(context).trim_end();
429 let lhs = if let Some(lifetime_str) =
430 rewrite_lifetime_param(context, shape, bound_generic_params)
432 format!("for<{}> {}{}", lifetime_str, type_str, colon)
434 format!("{}{}", type_str, colon)
437 rewrite_assign_rhs(context, lhs, bounds, &RhsAssignKind::Bounds, shape)?
439 ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
443 }) => rewrite_bounded_lifetime(lifetime, bounds, context, shape)?,
444 ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
449 let lhs_ty_str = lhs_ty.rewrite(context, shape).map(|lhs| lhs + " =")?;
450 rewrite_assign_rhs(context, lhs_ty_str, &**rhs_ty, &RhsAssignKind::Ty, shape)?
458 impl Rewrite for ast::GenericArg {
459 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
461 ast::GenericArg::Lifetime(ref lt) => lt.rewrite(context, shape),
462 ast::GenericArg::Type(ref ty) => ty.rewrite(context, shape),
463 ast::GenericArg::Const(ref const_) => const_.rewrite(context, shape),
468 fn rewrite_generic_args(
469 gen_args: &ast::GenericArgs,
470 context: &RewriteContext<'_>,
473 ) -> Option<String> {
475 ast::GenericArgs::AngleBracketed(ref data) if !data.args.is_empty() => {
480 ast::AngleBracketedArg::Arg(generic_arg) => {
481 SegmentParam::from_generic_arg(generic_arg)
483 ast::AngleBracketedArg::Constraint(constraint) => {
484 SegmentParam::Binding(constraint)
487 .collect::<Vec<_>>();
489 overflow::rewrite_with_angle_brackets(context, "", args.iter(), shape, span)
491 ast::GenericArgs::Parenthesized(ref data) => format_function_type(
492 data.inputs.iter().map(|x| &**x),
499 _ => Some("".to_owned()),
503 fn rewrite_bounded_lifetime(
505 bounds: &[ast::GenericBound],
506 context: &RewriteContext<'_>,
508 ) -> Option<String> {
509 let result = lt.rewrite(context, shape)?;
511 if bounds.is_empty() {
514 let colon = type_bound_colon(context);
515 let overhead = last_line_width(&result) + colon.len();
516 let result = format!(
520 join_bounds(context, shape.sub_width(overhead)?, bounds, true)?
526 impl Rewrite for ast::AnonConst {
527 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
528 format_expr(&self.value, ExprType::SubExpression, context, shape)
532 impl Rewrite for ast::Lifetime {
533 fn rewrite(&self, context: &RewriteContext<'_>, _: Shape) -> Option<String> {
534 Some(rewrite_ident(context, self.ident).to_owned())
538 impl Rewrite for ast::GenericBound {
539 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
541 ast::GenericBound::Trait(ref poly_trait_ref, trait_bound_modifier) => {
542 let snippet = context.snippet(self.span());
543 let has_paren = snippet.starts_with('(') && snippet.ends_with(')');
544 let rewrite = match trait_bound_modifier {
545 ast::TraitBoundModifier::None => poly_trait_ref.rewrite(context, shape),
546 ast::TraitBoundModifier::Maybe => poly_trait_ref
547 .rewrite(context, shape.offset_left(1)?)
548 .map(|s| format!("?{}", s)),
549 ast::TraitBoundModifier::MaybeConst => poly_trait_ref
550 .rewrite(context, shape.offset_left(7)?)
551 .map(|s| format!("~const {}", s)),
552 ast::TraitBoundModifier::MaybeConstMaybe => poly_trait_ref
553 .rewrite(context, shape.offset_left(8)?)
554 .map(|s| format!("~const ?{}", s)),
556 rewrite.map(|s| if has_paren { format!("({})", s) } else { s })
558 ast::GenericBound::Outlives(ref lifetime) => lifetime.rewrite(context, shape),
563 impl Rewrite for ast::GenericBounds {
564 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
566 return Some(String::new());
569 join_bounds(context, shape, self, true)
573 impl Rewrite for ast::GenericParam {
574 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
575 let mut result = String::with_capacity(128);
576 // FIXME: If there are more than one attributes, this will force multiline.
577 match self.attrs.rewrite(context, shape) {
578 Some(ref rw) if !rw.is_empty() => {
580 // When rewriting generic params, an extra newline should be put
581 // if the attributes end with a doc comment
582 if let Some(true) = self.attrs.last().map(|a| a.is_doc_comment()) {
583 result.push_str(&shape.indent.to_string_with_newline(context.config));
591 if let ast::GenericParamKind::Const {
597 result.push_str("const ");
598 result.push_str(rewrite_ident(context, self.ident));
599 result.push_str(": ");
600 result.push_str(&ty.rewrite(context, shape)?);
601 if let Some(default) = default {
602 let eq_str = match context.config.type_punctuation_density() {
603 TypeDensity::Compressed => "=",
604 TypeDensity::Wide => " = ",
606 result.push_str(eq_str);
607 let budget = shape.width.checked_sub(result.len())?;
608 let rewrite = default.rewrite(context, Shape::legacy(budget, shape.indent))?;
609 result.push_str(&rewrite);
612 result.push_str(rewrite_ident(context, self.ident));
615 if !self.bounds.is_empty() {
616 result.push_str(type_bound_colon(context));
617 result.push_str(&self.bounds.rewrite(context, shape)?)
619 if let ast::GenericParamKind::Type {
620 default: Some(ref def),
623 let eq_str = match context.config.type_punctuation_density() {
624 TypeDensity::Compressed => "=",
625 TypeDensity::Wide => " = ",
627 result.push_str(eq_str);
628 let budget = shape.width.checked_sub(result.len())?;
630 def.rewrite(context, Shape::legacy(budget, shape.indent + result.len()))?;
631 result.push_str(&rewrite);
638 impl Rewrite for ast::PolyTraitRef {
639 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
640 if let Some(lifetime_str) =
641 rewrite_lifetime_param(context, shape, &self.bound_generic_params)
643 // 6 is "for<> ".len()
644 let extra_offset = lifetime_str.len() + 6;
647 .rewrite(context, shape.offset_left(extra_offset)?)?;
649 Some(format!("for<{}> {}", lifetime_str, path_str))
651 self.trait_ref.rewrite(context, shape)
656 impl Rewrite for ast::TraitRef {
657 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
658 rewrite_path(context, PathContext::Type, None, &self.path, shape)
662 impl Rewrite for ast::Ty {
663 fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
665 ast::TyKind::TraitObject(ref bounds, tobj_syntax) => {
666 // we have to consider 'dyn' keyword is used or not!!!
667 let is_dyn = tobj_syntax == ast::TraitObjectSyntax::Dyn;
668 // 4 is length of 'dyn '
669 let shape = if is_dyn { shape.offset_left(4)? } else { shape };
670 let mut res = bounds.rewrite(context, shape)?;
671 // We may have falsely removed a trailing `+` inside macro call.
672 if context.inside_macro() && bounds.len() == 1 {
673 if context.snippet(self.span).ends_with('+') && !res.ends_with('+') {
678 Some(format!("dyn {}", res))
683 ast::TyKind::Ptr(ref mt) => {
684 let prefix = match mt.mutbl {
685 Mutability::Mut => "*mut ",
686 Mutability::Not => "*const ",
689 rewrite_unary_prefix(context, prefix, &*mt.ty, shape)
691 ast::TyKind::Rptr(ref lifetime, ref mt) => {
692 let mut_str = format_mutability(mt.mutbl);
693 let mut_len = mut_str.len();
694 let mut result = String::with_capacity(128);
696 let ref_hi = context.snippet_provider.span_after(self.span(), "&");
697 let mut cmnt_lo = ref_hi;
699 if let Some(ref lifetime) = *lifetime {
700 let lt_budget = shape.width.checked_sub(2 + mut_len)?;
701 let lt_str = lifetime.rewrite(
703 Shape::legacy(lt_budget, shape.indent + 2 + mut_len),
705 let before_lt_span = mk_sp(cmnt_lo, lifetime.ident.span.lo());
706 if contains_comment(context.snippet(before_lt_span)) {
707 result = combine_strs_with_missing_comments(
716 result.push_str(<_str);
719 cmnt_lo = lifetime.ident.span.hi();
722 if ast::Mutability::Mut == mt.mutbl {
723 let mut_hi = context.snippet_provider.span_after(self.span(), "mut");
724 let before_mut_span = mk_sp(cmnt_lo, mut_hi - BytePos::from_usize(3));
725 if contains_comment(context.snippet(before_mut_span)) {
726 result = combine_strs_with_missing_comments(
735 result.push_str(mut_str);
740 let before_ty_span = mk_sp(cmnt_lo, mt.ty.span.lo());
741 if contains_comment(context.snippet(before_ty_span)) {
742 result = combine_strs_with_missing_comments(
745 &mt.ty.rewrite(context, shape)?,
751 let used_width = last_line_width(&result);
752 let budget = shape.width.checked_sub(used_width)?;
755 .rewrite(context, Shape::legacy(budget, shape.indent + used_width))?;
756 result.push_str(&ty_str);
761 // FIXME: we drop any comments here, even though it's a silly place to put
763 ast::TyKind::Paren(ref ty) => {
764 if context.config.version() == Version::One
765 || context.config.indent_style() == IndentStyle::Visual
767 let budget = shape.width.checked_sub(2)?;
769 .rewrite(context, Shape::legacy(budget, shape.indent + 1))
770 .map(|ty_str| format!("({})", ty_str));
774 if let Some(sh) = shape.sub_width(2) {
775 if let Some(ref s) = ty.rewrite(context, sh) {
776 if !s.contains('\n') {
777 return Some(format!("({})", s));
782 let indent_str = shape.indent.to_string_with_newline(context.config);
784 .block_indent(context.config.tab_spaces())
785 .with_max_width(context.config);
786 let rw = ty.rewrite(context, shape)?;
789 shape.to_string_with_newline(context.config),
794 ast::TyKind::Slice(ref ty) => {
795 let budget = shape.width.checked_sub(4)?;
796 ty.rewrite(context, Shape::legacy(budget, shape.indent + 1))
797 .map(|ty_str| format!("[{}]", ty_str))
799 ast::TyKind::Tup(ref items) => {
800 rewrite_tuple(context, items.iter(), self.span, shape, items.len() == 1)
802 ast::TyKind::Path(ref q_self, ref path) => {
803 rewrite_path(context, PathContext::Type, q_self.as_ref(), path, shape)
805 ast::TyKind::Array(ref ty, ref repeats) => rewrite_pair(
808 PairParts::new("[", "; ", "]"),
811 SeparatorPlace::Back,
813 ast::TyKind::Infer => {
814 if shape.width >= 1 {
820 ast::TyKind::BareFn(ref bare_fn) => rewrite_bare_fn(bare_fn, self.span, context, shape),
821 ast::TyKind::Never => Some(String::from("!")),
822 ast::TyKind::MacCall(ref mac) => {
823 rewrite_macro(mac, None, context, shape, MacroPosition::Expression)
825 ast::TyKind::ImplicitSelf => Some(String::from("")),
826 ast::TyKind::ImplTrait(_, ref it) => {
827 // Empty trait is not a parser error.
829 return Some("impl".to_owned());
831 let rw = if context.config.version() == Version::One {
832 it.rewrite(context, shape)
834 join_bounds(context, shape, it, false)
837 let space = if it_str.is_empty() { "" } else { " " };
838 format!("impl{}{}", space, it_str)
841 ast::TyKind::CVarArgs => Some("...".to_owned()),
842 ast::TyKind::Err => Some(context.snippet(self.span).to_owned()),
843 ast::TyKind::Typeof(ref anon_const) => rewrite_call(
846 &[anon_const.value.clone()],
855 bare_fn: &ast::BareFnTy,
857 context: &RewriteContext<'_>,
859 ) -> Option<String> {
860 debug!("rewrite_bare_fn {:#?}", shape);
862 let mut result = String::with_capacity(128);
864 if let Some(ref lifetime_str) = rewrite_lifetime_param(context, shape, &bare_fn.generic_params)
866 result.push_str("for<");
867 // 6 = "for<> ".len(), 4 = "for<".
868 // This doesn't work out so nicely for multiline situation with lots of
869 // rightward drift. If that is a problem, we could use the list stuff.
870 result.push_str(lifetime_str);
871 result.push_str("> ");
874 result.push_str(crate::utils::format_unsafety(bare_fn.unsafety));
876 result.push_str(&format_extern(
878 context.config.force_explicit_abi(),
882 result.push_str("fn");
884 let func_ty_shape = if context.use_block_indent() {
885 shape.offset_left(result.len())?
887 shape.visual_indent(result.len()).sub_width(result.len())?
890 let rewrite = format_function_type(
891 bare_fn.decl.inputs.iter(),
892 &bare_fn.decl.output,
893 bare_fn.decl.c_variadic(),
899 result.push_str(&rewrite);
904 fn is_generic_bounds_in_order(generic_bounds: &[ast::GenericBound]) -> bool {
905 let is_trait = |b: &ast::GenericBound| match b {
906 ast::GenericBound::Outlives(..) => false,
907 ast::GenericBound::Trait(..) => true,
909 let is_lifetime = |b: &ast::GenericBound| !is_trait(b);
910 let last_trait_index = generic_bounds.iter().rposition(is_trait);
911 let first_lifetime_index = generic_bounds.iter().position(is_lifetime);
912 match (last_trait_index, first_lifetime_index) {
913 (Some(last_trait_index), Some(first_lifetime_index)) => {
914 last_trait_index < first_lifetime_index
921 context: &RewriteContext<'_>,
923 items: &[ast::GenericBound],
925 ) -> Option<String> {
926 join_bounds_inner(context, shape, items, need_indent, false)
929 fn join_bounds_inner(
930 context: &RewriteContext<'_>,
932 items: &[ast::GenericBound],
935 ) -> Option<String> {
936 debug_assert!(!items.is_empty());
938 let generic_bounds_in_order = is_generic_bounds_in_order(items);
939 let is_bound_extendable = |s: &str, b: &ast::GenericBound| match b {
940 ast::GenericBound::Outlives(..) => true,
941 ast::GenericBound::Trait(..) => last_line_extendable(s),
944 let result = items.iter().enumerate().try_fold(
945 (String::new(), None, false),
946 |(strs, prev_trailing_span, prev_extendable), (i, item)| {
947 let trailing_span = if i < items.len() - 1 {
950 .span_before(mk_sp(items[i + 1].span().lo(), item.span().hi()), "+");
952 Some(mk_sp(item.span().hi(), hi))
956 let (leading_span, has_leading_comment) = if i > 0 {
959 .span_after(mk_sp(items[i - 1].span().hi(), item.span().lo()), "+");
961 let span = mk_sp(lo, item.span().lo());
963 let has_comments = contains_comment(context.snippet(span));
965 (Some(mk_sp(lo, item.span().lo())), has_comments)
969 let prev_has_trailing_comment = match prev_trailing_span {
970 Some(ts) => contains_comment(context.snippet(ts)),
974 let shape = if need_indent && force_newline {
976 .block_indent(context.config.tab_spaces())
977 .with_max_width(context.config)
981 let whitespace = if force_newline && (!prev_extendable || !generic_bounds_in_order) {
984 .to_string_with_newline(context.config)
990 let joiner = match context.config.type_punctuation_density() {
991 TypeDensity::Compressed => String::from("+"),
992 TypeDensity::Wide => whitespace + "+ ",
994 let joiner = if has_leading_comment {
999 let joiner = if prev_has_trailing_comment {
1005 let (extendable, trailing_str) = if i == 0 {
1006 let bound_str = item.rewrite(context, shape)?;
1007 (is_bound_extendable(&bound_str, item), bound_str)
1009 let bound_str = &item.rewrite(context, shape)?;
1010 match leading_span {
1011 Some(ls) if has_leading_comment => (
1012 is_bound_extendable(bound_str, item),
1013 combine_strs_with_missing_comments(
1014 context, joiner, bound_str, ls, shape, true,
1018 is_bound_extendable(bound_str, item),
1019 String::from(joiner) + bound_str,
1023 match prev_trailing_span {
1024 Some(ts) if prev_has_trailing_comment => combine_strs_with_missing_comments(
1032 .map(|v| (v, trailing_span, extendable)),
1033 _ => Some((strs + &trailing_str, trailing_span, extendable)),
1040 && (result.0.contains('\n') || result.0.len() > shape.width)
1042 join_bounds_inner(context, shape, items, need_indent, true)
1048 pub(crate) fn opaque_ty(ty: &Option<ptr::P<ast::Ty>>) -> Option<&ast::GenericBounds> {
1049 ty.as_ref().and_then(|t| match &t.kind {
1050 ast::TyKind::ImplTrait(_, bounds) => Some(bounds),
1055 pub(crate) fn can_be_overflowed_type(
1056 context: &RewriteContext<'_>,
1061 ast::TyKind::Tup(..) => context.use_block_indent() && len == 1,
1062 ast::TyKind::Rptr(_, ref mutty) | ast::TyKind::Ptr(ref mutty) => {
1063 can_be_overflowed_type(context, &*mutty.ty, len)
1069 /// Returns `None` if there is no `LifetimeDef` in the given generic parameters.
1070 pub(crate) fn rewrite_lifetime_param(
1071 context: &RewriteContext<'_>,
1073 generic_params: &[ast::GenericParam],
1074 ) -> Option<String> {
1075 let result = generic_params
1077 .filter(|p| matches!(p.kind, ast::GenericParamKind::Lifetime))
1078 .map(|lt| lt.rewrite(context, shape))
1079 .collect::<Option<Vec<_>>>()?
1081 if result.is_empty() {