src/tools/rustfmt/src/types.rs

   1 use std::iter::ExactSizeIterator;
   2 use std::ops::Deref;
   3
   4 use rustc_ast::ast::{self, FnRetTy, Mutability, Term};
   5 use rustc_ast::ptr;
   6 use rustc_span::{symbol::kw, BytePos, Pos, Span};
   7
   8 use crate::comment::{combine_strs_with_missing_comments, contains_comment};
   9 use crate::config::lists::*;
  10 use crate::config::{IndentStyle, TypeDensity, Version};
  11 use crate::expr::{
  12     format_expr, rewrite_assign_rhs, rewrite_call, rewrite_tuple, rewrite_unary_prefix, ExprType,
  13     RhsAssignKind,
  14 };
  15 use crate::lists::{
  16     definitive_tactic, itemize_list, write_list, ListFormatting, ListItem, Separator,
  17 };
  18 use crate::macros::{rewrite_macro, MacroPosition};
  19 use crate::overflow;
  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;
  25 use crate::utils::{
  26     colon_spaces, extra_offset, first_line_width, format_extern, format_mutability,
  27     last_line_extendable, last_line_width, mk_sp, rewrite_ident,
  28 };
  29
  30 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
  31 pub(crate) enum PathContext {
  32     Expr,
  33     Type,
  34     Import,
  35 }
  36
  37 // Does not wrap on simple segments.
  38 pub(crate) fn rewrite_path(
  39     context: &RewriteContext<'_>,
  40     path_context: PathContext,
  41     qself: &Option<ptr::P<ast::QSelf>>,
  42     path: &ast::Path,
  43     shape: Shape,
  44 ) -> Option<String> {
  45     let skip_count = qself.as_ref().map_or(0, |x| x.position);
  46
  47     let mut result = if path.is_global() && qself.is_none() && path_context != PathContext::Import {
  48         "::".to_owned()
  49     } else {
  50         String::new()
  51     };
  52
  53     let mut span_lo = path.span.lo();
  54
  55     if let Some(qself) = qself {
  56         result.push('<');
  57
  58         let fmt_ty = qself.ty.rewrite(context, shape)?;
  59         result.push_str(&fmt_ty);
  60
  61         if skip_count > 0 {
  62             result.push_str(" as ");
  63             if path.is_global() && path_context != PathContext::Import {
  64                 result.push_str("::");
  65             }
  66
  67             // 3 = ">::".len()
  68             let shape = shape.sub_width(3)?;
  69
  70             result = rewrite_path_segments(
  71                 PathContext::Type,
  72                 result,
  73                 path.segments.iter().take(skip_count),
  74                 span_lo,
  75                 path.span.hi(),
  76                 context,
  77                 shape,
  78             )?;
  79         }
  80
  81         result.push_str(">::");
  82         span_lo = qself.ty.span.hi() + BytePos(1);
  83     }
  84
  85     rewrite_path_segments(
  86         path_context,
  87         result,
  88         path.segments.iter().skip(skip_count),
  89         span_lo,
  90         path.span.hi(),
  91         context,
  92         shape,
  93     )
  94 }
  95
  96 fn rewrite_path_segments<'a, I>(
  97     path_context: PathContext,
  98     mut buffer: String,
  99     iter: I,
 100     mut span_lo: BytePos,
 101     span_hi: BytePos,
 102     context: &RewriteContext<'_>,
 103     shape: Shape,
 104 ) -> Option<String>
 105 where
 106     I: Iterator<Item = &'a ast::PathSegment>,
 107 {
 108     let mut first = true;
 109     let shape = shape.visual_indent(0);
 110
 111     for segment in iter {
 112         // Indicates a global path, shouldn't be rendered.
 113         if segment.ident.name == kw::PathRoot {
 114             continue;
 115         }
 116         if first {
 117             first = false;
 118         } else {
 119             buffer.push_str("::");
 120         }
 121
 122         let extra_offset = extra_offset(&buffer, shape);
 123         let new_shape = shape.shrink_left(extra_offset)?;
 124         let segment_string = rewrite_segment(
 125             path_context,
 126             segment,
 127             &mut span_lo,
 128             span_hi,
 129             context,
 130             new_shape,
 131         )?;
 132
 133         buffer.push_str(&segment_string);
 134     }
 135
 136     Some(buffer)
 137 }
 138
 139 #[derive(Debug)]
 140 pub(crate) enum SegmentParam<'a> {
 141     Const(&'a ast::AnonConst),
 142     LifeTime(&'a ast::Lifetime),
 143     Type(&'a ast::Ty),
 144     Binding(&'a ast::AssocConstraint),
 145 }
 146
 147 impl<'a> SegmentParam<'a> {
 148     fn from_generic_arg(arg: &ast::GenericArg) -> SegmentParam<'_> {
 149         match arg {
 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_),
 153         }
 154     }
 155 }
 156
 157 impl<'a> Spanned for SegmentParam<'a> {
 158     fn span(&self) -> Span {
 159         match *self {
 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,
 164         }
 165     }
 166 }
 167
 168 impl<'a> Rewrite for SegmentParam<'a> {
 169     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 170         match *self {
 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),
 175         }
 176     }
 177 }
 178
 179 impl Rewrite for ast::AssocConstraint {
 180     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 181         use ast::AssocConstraintKind::{Bound, Equality};
 182
 183         let mut result = String::with_capacity(128);
 184         result.push_str(rewrite_ident(context, self.ident));
 185
 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);
 191         }
 192
 193         let infix = match (&self.kind, context.config.type_punctuation_density()) {
 194             (Bound { .. }, _) => ": ",
 195             (Equality { .. }, TypeDensity::Wide) => " = ",
 196             (Equality { .. }, TypeDensity::Compressed) => "=",
 197         };
 198         result.push_str(infix);
 199
 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);
 204
 205         Some(result)
 206     }
 207 }
 208
 209 impl Rewrite for ast::AssocConstraintKind {
 210     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 211         match self {
 212             ast::AssocConstraintKind::Equality { term } => match term {
 213                 Term::Ty(ty) => ty.rewrite(context, shape),
 214                 Term::Const(c) => c.rewrite(context, shape),
 215             },
 216             ast::AssocConstraintKind::Bound { bounds } => bounds.rewrite(context, shape),
 217         }
 218     }
 219 }
 220
 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.
 223 //
 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.
 226 //
 227 // span_hi is assumed equal to the end of the entire path.
 228 //
 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.
 231 fn rewrite_segment(
 232     path_context: PathContext,
 233     segment: &ast::PathSegment,
 234     span_lo: &mut BytePos,
 235     span_hi: BytePos,
 236     context: &RewriteContext<'_>,
 237     shape: Shape,
 238 ) -> Option<String> {
 239     let mut result = String::with_capacity(128);
 240     result.push_str(rewrite_ident(context, segment.ident));
 241
 242     let ident_len = result.len();
 243     let shape = if context.use_block_indent() {
 244         shape.offset_left(ident_len)?
 245     } else {
 246         shape.shrink_left(ident_len)?
 247     };
 248
 249     if let Some(ref args) = segment.args {
 250         let generics_str = rewrite_generic_args(args, context, shape, mk_sp(*span_lo, span_hi))?;
 251         match **args {
 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()))
 259                     .trim();
 260                 let force_separator = context.inside_macro() && separator_snippet.starts_with("::");
 261                 let separator = if path_context == PathContext::Expr || force_separator {
 262                     "::"
 263                 } else {
 264                     ""
 265                 };
 266                 result.push_str(separator);
 267
 268                 // Update position of last bracket.
 269                 *span_lo = context
 270                     .snippet_provider
 271                     .span_after(mk_sp(*span_lo, span_hi), "<");
 272             }
 273             _ => (),
 274         }
 275         result.push_str(&generics_str)
 276     }
 277
 278     Some(result)
 279 }
 280
 281 fn format_function_type<'a, I>(
 282     inputs: I,
 283     output: &FnRetTy,
 284     variadic: bool,
 285     span: Span,
 286     context: &RewriteContext<'_>,
 287     shape: Shape,
 288 ) -> Option<String>
 289 where
 290     I: ExactSizeIterator,
 291     <I as Iterator>::Item: Deref,
 292     <I::Item as Deref>::Target: Rewrite + Spanned + 'a,
 293 {
 294     debug!("format_function_type {:#?}", shape);
 295
 296     let ty_shape = match context.config.indent_style() {
 297         // 4 = " -> "
 298         IndentStyle::Block => shape.offset_left(4)?,
 299         IndentStyle::Visual => shape.block_left(4)?,
 300     };
 301     let output = match *output {
 302         FnRetTy::Ty(ref ty) => {
 303             let type_str = ty.rewrite(context, ty_shape)?;
 304             format!(" -> {}", type_str)
 305         }
 306         FnRetTy::Default(..) => String::new(),
 307     };
 308
 309     let list_shape = if context.use_block_indent() {
 310         Shape::indented(
 311             shape.block().indent.block_indent(context.config),
 312             context.config,
 313         )
 314     } else {
 315         // 2 for ()
 316         let budget = shape.width.checked_sub(2)?;
 317         // 1 for (
 318         let offset = shape.indent + 1;
 319         Shape::legacy(budget, offset)
 320     };
 321
 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
 328             .snippet_provider
 329             .span_to_snippet(mk_sp(list_lo, list_hi))?
 330             .trim();
 331         let comment = if comment.starts_with("//") {
 332             format!(
 333                 "{}{}{}",
 334                 &list_shape.indent.to_string_with_newline(context.config),
 335                 comment,
 336                 &shape.block().indent.to_string_with_newline(context.config)
 337             )
 338         } else {
 339             comment.to_string()
 340         };
 341         (comment, tactic)
 342     } else {
 343         let items = itemize_list(
 344             context.snippet_provider,
 345             inputs,
 346             ")",
 347             ",",
 348             |arg| arg.span().lo(),
 349             |arg| arg.span().hi(),
 350             |arg| arg.rewrite(context, list_shape),
 351             list_lo,
 352             span.hi(),
 353             false,
 354         );
 355
 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
 360         } else {
 361             context.config.trailing_comma()
 362         };
 363
 364         let fmt = ListFormatting::new(list_shape, context.config)
 365             .tactic(tactic)
 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)
 370     };
 371
 372     let args = if tactic == DefinitiveListTactic::Horizontal
 373         || !context.use_block_indent()
 374         || is_inputs_empty
 375     {
 376         format!("({})", list_str)
 377     } else {
 378         format!(
 379             "({}{}{})",
 380             list_shape.indent.to_string_with_newline(context.config),
 381             list_str,
 382             shape.block().indent.to_string_with_newline(context.config),
 383         )
 384     };
 385     if output.is_empty() || last_line_width(&args) + first_line_width(&output) <= shape.width {
 386         Some(format!("{}{}", args, output))
 387     } else {
 388         Some(format!(
 389             "{}\n{}{}",
 390             args,
 391             list_shape.indent.to_string(context.config),
 392             output.trim_start()
 393         ))
 394     }
 395 }
 396
 397 fn type_bound_colon(context: &RewriteContext<'_>) -> &'static str {
 398     colon_spaces(context.config)
 399 }
 400
 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
 406     } else {
 407         definitive_tactic(
 408             item_vec,
 409             ListTactic::HorizontalVertical,
 410             Separator::Comma,
 411             // 2 is for the case of ',\n'
 412             shape.width.saturating_sub(2 + output.len()),
 413         )
 414     }
 415 }
 416
 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,
 423                 ref bounded_ty,
 424                 ref bounds,
 425                 ..
 426             }) => {
 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)
 431                 {
 432                     format!("for<{}> {}{}", lifetime_str, type_str, colon)
 433                 } else {
 434                     format!("{}{}", type_str, colon)
 435                 };
 436
 437                 rewrite_assign_rhs(context, lhs, bounds, &RhsAssignKind::Bounds, shape)?
 438             }
 439             ast::WherePredicate::RegionPredicate(ast::WhereRegionPredicate {
 440                 ref lifetime,
 441                 ref bounds,
 442                 ..
 443             }) => rewrite_bounded_lifetime(lifetime, bounds, context, shape)?,
 444             ast::WherePredicate::EqPredicate(ast::WhereEqPredicate {
 445                 ref lhs_ty,
 446                 ref rhs_ty,
 447                 ..
 448             }) => {
 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)?
 451             }
 452         };
 453
 454         Some(result)
 455     }
 456 }
 457
 458 impl Rewrite for ast::GenericArg {
 459     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 460         match *self {
 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),
 464         }
 465     }
 466 }
 467
 468 fn rewrite_generic_args(
 469     gen_args: &ast::GenericArgs,
 470     context: &RewriteContext<'_>,
 471     shape: Shape,
 472     span: Span,
 473 ) -> Option<String> {
 474     match gen_args {
 475         ast::GenericArgs::AngleBracketed(ref data) if !data.args.is_empty() => {
 476             let args = data
 477                 .args
 478                 .iter()
 479                 .map(|x| match x {
 480                     ast::AngleBracketedArg::Arg(generic_arg) => {
 481                         SegmentParam::from_generic_arg(generic_arg)
 482                     }
 483                     ast::AngleBracketedArg::Constraint(constraint) => {
 484                         SegmentParam::Binding(constraint)
 485                     }
 486                 })
 487                 .collect::<Vec<_>>();
 488
 489             overflow::rewrite_with_angle_brackets(context, "", args.iter(), shape, span)
 490         }
 491         ast::GenericArgs::Parenthesized(ref data) => format_function_type(
 492             data.inputs.iter().map(|x| &**x),
 493             &data.output,
 494             false,
 495             data.span,
 496             context,
 497             shape,
 498         ),
 499         _ => Some("".to_owned()),
 500     }
 501 }
 502
 503 fn rewrite_bounded_lifetime(
 504     lt: &ast::Lifetime,
 505     bounds: &[ast::GenericBound],
 506     context: &RewriteContext<'_>,
 507     shape: Shape,
 508 ) -> Option<String> {
 509     let result = lt.rewrite(context, shape)?;
 510
 511     if bounds.is_empty() {
 512         Some(result)
 513     } else {
 514         let colon = type_bound_colon(context);
 515         let overhead = last_line_width(&result) + colon.len();
 516         let result = format!(
 517             "{}{}{}",
 518             result,
 519             colon,
 520             join_bounds(context, shape.sub_width(overhead)?, bounds, true)?
 521         );
 522         Some(result)
 523     }
 524 }
 525
 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)
 529     }
 530 }
 531
 532 impl Rewrite for ast::Lifetime {
 533     fn rewrite(&self, context: &RewriteContext<'_>, _: Shape) -> Option<String> {
 534         Some(rewrite_ident(context, self.ident).to_owned())
 535     }
 536 }
 537
 538 impl Rewrite for ast::GenericBound {
 539     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 540         match *self {
 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)),
 555                 };
 556                 rewrite.map(|s| if has_paren { format!("({})", s) } else { s })
 557             }
 558             ast::GenericBound::Outlives(ref lifetime) => lifetime.rewrite(context, shape),
 559         }
 560     }
 561 }
 562
 563 impl Rewrite for ast::GenericBounds {
 564     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 565         if self.is_empty() {
 566             return Some(String::new());
 567         }
 568
 569         join_bounds(context, shape, self, true)
 570     }
 571 }
 572
 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() => {
 579                 result.push_str(rw);
 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));
 584                 } else {
 585                     result.push(' ');
 586                 }
 587             }
 588             _ => (),
 589         }
 590
 591         if let ast::GenericParamKind::Const {
 592             ref ty,
 593             kw_span: _,
 594             default,
 595         } = &self.kind
 596         {
 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 => " = ",
 605                 };
 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);
 610             }
 611         } else {
 612             result.push_str(rewrite_ident(context, self.ident));
 613         }
 614
 615         if !self.bounds.is_empty() {
 616             result.push_str(type_bound_colon(context));
 617             result.push_str(&self.bounds.rewrite(context, shape)?)
 618         }
 619         if let ast::GenericParamKind::Type {
 620             default: Some(ref def),
 621         } = self.kind
 622         {
 623             let eq_str = match context.config.type_punctuation_density() {
 624                 TypeDensity::Compressed => "=",
 625                 TypeDensity::Wide => " = ",
 626             };
 627             result.push_str(eq_str);
 628             let budget = shape.width.checked_sub(result.len())?;
 629             let rewrite =
 630                 def.rewrite(context, Shape::legacy(budget, shape.indent + result.len()))?;
 631             result.push_str(&rewrite);
 632         }
 633
 634         Some(result)
 635     }
 636 }
 637
 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)
 642         {
 643             // 6 is "for<> ".len()
 644             let extra_offset = lifetime_str.len() + 6;
 645             let path_str = self
 646                 .trait_ref
 647                 .rewrite(context, shape.offset_left(extra_offset)?)?;
 648
 649             Some(format!("for<{}> {}", lifetime_str, path_str))
 650         } else {
 651             self.trait_ref.rewrite(context, shape)
 652         }
 653     }
 654 }
 655
 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)
 659     }
 660 }
 661
 662 impl Rewrite for ast::Ty {
 663     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
 664         match self.kind {
 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('+') {
 674                         res.push('+');
 675                     }
 676                 }
 677                 if is_dyn {
 678                     Some(format!("dyn {}", res))
 679                 } else {
 680                     Some(res)
 681                 }
 682             }
 683             ast::TyKind::Ptr(ref mt) => {
 684                 let prefix = match mt.mutbl {
 685                     Mutability::Mut => "*mut ",
 686                     Mutability::Not => "*const ",
 687                 };
 688
 689                 rewrite_unary_prefix(context, prefix, &*mt.ty, shape)
 690             }
 691             ast::TyKind::Ref(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);
 695                 result.push('&');
 696                 let ref_hi = context.snippet_provider.span_after(self.span(), "&");
 697                 let mut cmnt_lo = ref_hi;
 698
 699                 if let Some(ref lifetime) = *lifetime {
 700                     let lt_budget = shape.width.checked_sub(2 + mut_len)?;
 701                     let lt_str = lifetime.rewrite(
 702                         context,
 703                         Shape::legacy(lt_budget, shape.indent + 2 + mut_len),
 704                     )?;
 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(
 708                             context,
 709                             &result,
 710                             &lt_str,
 711                             before_lt_span,
 712                             shape,
 713                             true,
 714                         )?;
 715                     } else {
 716                         result.push_str(&lt_str);
 717                     }
 718                     result.push(' ');
 719                     cmnt_lo = lifetime.ident.span.hi();
 720                 }
 721
 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(
 727                             context,
 728                             result.trim_end(),
 729                             mut_str,
 730                             before_mut_span,
 731                             shape,
 732                             true,
 733                         )?;
 734                     } else {
 735                         result.push_str(mut_str);
 736                     }
 737                     cmnt_lo = mut_hi;
 738                 }
 739
 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(
 743                         context,
 744                         result.trim_end(),
 745                         &mt.ty.rewrite(context, shape)?,
 746                         before_ty_span,
 747                         shape,
 748                         true,
 749                     )?;
 750                 } else {
 751                     let used_width = last_line_width(&result);
 752                     let budget = shape.width.checked_sub(used_width)?;
 753                     let ty_str = mt
 754                         .ty
 755                         .rewrite(context, Shape::legacy(budget, shape.indent + used_width))?;
 756                     result.push_str(&ty_str);
 757                 }
 758
 759                 Some(result)
 760             }
 761             // FIXME: we drop any comments here, even though it's a silly place to put
 762             // comments.
 763             ast::TyKind::Paren(ref ty) => {
 764                 if context.config.version() == Version::One
 765                     || context.config.indent_style() == IndentStyle::Visual
 766                 {
 767                     let budget = shape.width.checked_sub(2)?;
 768                     return ty
 769                         .rewrite(context, Shape::legacy(budget, shape.indent + 1))
 770                         .map(|ty_str| format!("({})", ty_str));
 771                 }
 772
 773                 // 2 = ()
 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));
 778                         }
 779                     }
 780                 }
 781
 782                 let indent_str = shape.indent.to_string_with_newline(context.config);
 783                 let shape = shape
 784                     .block_indent(context.config.tab_spaces())
 785                     .with_max_width(context.config);
 786                 let rw = ty.rewrite(context, shape)?;
 787                 Some(format!(
 788                     "({}{}{})",
 789                     shape.to_string_with_newline(context.config),
 790                     rw,
 791                     indent_str
 792                 ))
 793             }
 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))
 798             }
 799             ast::TyKind::Tup(ref items) => {
 800                 rewrite_tuple(context, items.iter(), self.span, shape, items.len() == 1)
 801             }
 802             ast::TyKind::Path(ref q_self, ref path) => {
 803                 rewrite_path(context, PathContext::Type, q_self, path, shape)
 804             }
 805             ast::TyKind::Array(ref ty, ref repeats) => rewrite_pair(
 806                 &**ty,
 807                 &*repeats.value,
 808                 PairParts::new("[", "; ", "]"),
 809                 context,
 810                 shape,
 811                 SeparatorPlace::Back,
 812             ),
 813             ast::TyKind::Infer => {
 814                 if shape.width >= 1 {
 815                     Some("_".to_owned())
 816                 } else {
 817                     None
 818                 }
 819             }
 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)
 824             }
 825             ast::TyKind::ImplicitSelf => Some(String::from("")),
 826             ast::TyKind::ImplTrait(_, ref it) => {
 827                 // Empty trait is not a parser error.
 828                 if it.is_empty() {
 829                     return Some("impl".to_owned());
 830                 }
 831                 let rw = if context.config.version() == Version::One {
 832                     it.rewrite(context, shape)
 833                 } else {
 834                     join_bounds(context, shape, it, false)
 835                 };
 836                 rw.map(|it_str| {
 837                     let space = if it_str.is_empty() { "" } else { " " };
 838                     format!("impl{}{}", space, it_str)
 839                 })
 840             }
 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(
 844                 context,
 845                 "typeof",
 846                 &[anon_const.value.clone()],
 847                 self.span,
 848                 shape,
 849             ),
 850         }
 851     }
 852 }
 853
 854 fn rewrite_bare_fn(
 855     bare_fn: &ast::BareFnTy,
 856     span: Span,
 857     context: &RewriteContext<'_>,
 858     shape: Shape,
 859 ) -> Option<String> {
 860     debug!("rewrite_bare_fn {:#?}", shape);
 861
 862     let mut result = String::with_capacity(128);
 863
 864     if let Some(ref lifetime_str) = rewrite_lifetime_param(context, shape, &bare_fn.generic_params)
 865     {
 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("> ");
 872     }
 873
 874     result.push_str(crate::utils::format_unsafety(bare_fn.unsafety));
 875
 876     result.push_str(&format_extern(
 877         bare_fn.ext,
 878         context.config.force_explicit_abi(),
 879         false,
 880     ));
 881
 882     result.push_str("fn");
 883
 884     let func_ty_shape = if context.use_block_indent() {
 885         shape.offset_left(result.len())?
 886     } else {
 887         shape.visual_indent(result.len()).sub_width(result.len())?
 888     };
 889
 890     let rewrite = format_function_type(
 891         bare_fn.decl.inputs.iter(),
 892         &bare_fn.decl.output,
 893         bare_fn.decl.c_variadic(),
 894         span,
 895         context,
 896         func_ty_shape,
 897     )?;
 898
 899     result.push_str(&rewrite);
 900
 901     Some(result)
 902 }
 903
 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,
 908     };
 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
 915         }
 916         _ => true,
 917     }
 918 }
 919
 920 fn join_bounds(
 921     context: &RewriteContext<'_>,
 922     shape: Shape,
 923     items: &[ast::GenericBound],
 924     need_indent: bool,
 925 ) -> Option<String> {
 926     join_bounds_inner(context, shape, items, need_indent, false)
 927 }
 928
 929 fn join_bounds_inner(
 930     context: &RewriteContext<'_>,
 931     shape: Shape,
 932     items: &[ast::GenericBound],
 933     need_indent: bool,
 934     force_newline: bool,
 935 ) -> Option<String> {
 936     debug_assert!(!items.is_empty());
 937
 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),
 942     };
 943
 944     // Whether a GenericBound item is a PathSegment segment that includes internal array
 945     // that contains more than one item
 946     let is_item_with_multi_items_array = |item: &ast::GenericBound| match item {
 947         ast::GenericBound::Trait(ref poly_trait_ref, ..) => {
 948             let segments = &poly_trait_ref.trait_ref.path.segments;
 949             if segments.len() > 1 {
 950                 true
 951             } else {
 952                 if let Some(args_in) = &segments[0].args {
 953                     matches!(
 954                         args_in.deref(),
 955                         ast::GenericArgs::AngleBracketed(bracket_args)
 956                             if bracket_args.args.len() > 1
 957                     )
 958                 } else {
 959                     false
 960                 }
 961             }
 962         }
 963         _ => false,
 964     };
 965
 966     let result = items.iter().enumerate().try_fold(
 967         (String::new(), None, false),
 968         |(strs, prev_trailing_span, prev_extendable), (i, item)| {
 969             let trailing_span = if i < items.len() - 1 {
 970                 let hi = context
 971                     .snippet_provider
 972                     .span_before(mk_sp(items[i + 1].span().lo(), item.span().hi()), "+");
 973
 974                 Some(mk_sp(item.span().hi(), hi))
 975             } else {
 976                 None
 977             };
 978             let (leading_span, has_leading_comment) = if i > 0 {
 979                 let lo = context
 980                     .snippet_provider
 981                     .span_after(mk_sp(items[i - 1].span().hi(), item.span().lo()), "+");
 982
 983                 let span = mk_sp(lo, item.span().lo());
 984
 985                 let has_comments = contains_comment(context.snippet(span));
 986
 987                 (Some(mk_sp(lo, item.span().lo())), has_comments)
 988             } else {
 989                 (None, false)
 990             };
 991             let prev_has_trailing_comment = match prev_trailing_span {
 992                 Some(ts) => contains_comment(context.snippet(ts)),
 993                 _ => false,
 994             };
 995
 996             let shape = if need_indent && force_newline {
 997                 shape
 998                     .block_indent(context.config.tab_spaces())
 999                     .with_max_width(context.config)
1000             } else {
1001                 shape
1002             };
1003             let whitespace = if force_newline && (!prev_extendable || !generic_bounds_in_order) {
1004                 shape
1005                     .indent
1006                     .to_string_with_newline(context.config)
1007                     .to_string()
1008             } else {
1009                 String::from(" ")
1010             };
1011
1012             let joiner = match context.config.type_punctuation_density() {
1013                 TypeDensity::Compressed => String::from("+"),
1014                 TypeDensity::Wide => whitespace + "+ ",
1015             };
1016             let joiner = if has_leading_comment {
1017                 joiner.trim_end()
1018             } else {
1019                 &joiner
1020             };
1021             let joiner = if prev_has_trailing_comment {
1022                 joiner.trim_start()
1023             } else {
1024                 joiner
1025             };
1026
1027             let (extendable, trailing_str) = if i == 0 {
1028                 let bound_str = item.rewrite(context, shape)?;
1029                 (is_bound_extendable(&bound_str, item), bound_str)
1030             } else {
1031                 let bound_str = &item.rewrite(context, shape)?;
1032                 match leading_span {
1033                     Some(ls) if has_leading_comment => (
1034                         is_bound_extendable(bound_str, item),
1035                         combine_strs_with_missing_comments(
1036                             context, joiner, bound_str, ls, shape, true,
1037                         )?,
1038                     ),
1039                     _ => (
1040                         is_bound_extendable(bound_str, item),
1041                         String::from(joiner) + bound_str,
1042                     ),
1043                 }
1044             };
1045             match prev_trailing_span {
1046                 Some(ts) if prev_has_trailing_comment => combine_strs_with_missing_comments(
1047                     context,
1048                     &strs,
1049                     &trailing_str,
1050                     ts,
1051                     shape,
1052                     true,
1053                 )
1054                 .map(|v| (v, trailing_span, extendable)),
1055                 _ => Some((strs + &trailing_str, trailing_span, extendable)),
1056             }
1057         },
1058     )?;
1059
1060     // Whether to retry with a forced newline:
1061     //   Only if result is not already multiline and did not exceed line width,
1062     //   and either there is more than one item;
1063     //       or the single item is of type `Trait`,
1064     //          and any of the internal arrays contains more than one item;
1065     let retry_with_force_newline = match context.config.version() {
1066         Version::One => {
1067             !force_newline
1068                 && items.len() > 1
1069                 && (result.0.contains('\n') || result.0.len() > shape.width)
1070         }
1071         Version::Two if force_newline => false,
1072         Version::Two if (!result.0.contains('\n') && result.0.len() <= shape.width) => false,
1073         Version::Two if items.len() > 1 => true,
1074         Version::Two => is_item_with_multi_items_array(&items[0]),
1075     };
1076
1077     if retry_with_force_newline {
1078         join_bounds_inner(context, shape, items, need_indent, true)
1079     } else {
1080         Some(result.0)
1081     }
1082 }
1083
1084 pub(crate) fn opaque_ty(ty: &Option<ptr::P<ast::Ty>>) -> Option<&ast::GenericBounds> {
1085     ty.as_ref().and_then(|t| match &t.kind {
1086         ast::TyKind::ImplTrait(_, bounds) => Some(bounds),
1087         _ => None,
1088     })
1089 }
1090
1091 pub(crate) fn can_be_overflowed_type(
1092     context: &RewriteContext<'_>,
1093     ty: &ast::Ty,
1094     len: usize,
1095 ) -> bool {
1096     match ty.kind {
1097         ast::TyKind::Tup(..) => context.use_block_indent() && len == 1,
1098         ast::TyKind::Ref(_, ref mutty) | ast::TyKind::Ptr(ref mutty) => {
1099             can_be_overflowed_type(context, &*mutty.ty, len)
1100         }
1101         _ => false,
1102     }
1103 }
1104
1105 /// Returns `None` if there is no `LifetimeDef` in the given generic parameters.
1106 pub(crate) fn rewrite_lifetime_param(
1107     context: &RewriteContext<'_>,
1108     shape: Shape,
1109     generic_params: &[ast::GenericParam],
1110 ) -> Option<String> {
1111     let result = generic_params
1112         .iter()
1113         .filter(|p| matches!(p.kind, ast::GenericParamKind::Lifetime))
1114         .map(|lt| lt.rewrite(context, shape))
1115         .collect::<Option<Vec<_>>>()?
1116         .join(", ");
1117     if result.is_empty() {
1118         None
1119     } else {
1120         Some(result)
1121     }
1122 }