Merge pull request rust-lang#6217 from compiler-errors/sync-from-rust-2024-06-24

calebcartwright · CalebLItalien · commit 53e290dafda1 · 2024-07-03T17:23:47.000-04:00
subtree-push 2024-06-24

Merge commit from master
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -238,7 +238,7 @@
 
 ### Added
 
-- New configuration option (`skip_macro_invocations`)[https://rust-lang.github.io/rustfmt/?version=master&search=#skip_macro_invocations] [#5347](https://github.com/rust-lang/rustfmt/pull/5347) that can be used to globally define a single enumerated list of macro calls that rustfmt should skip formatting. rustfmt [currently also supports this via a custom tool attribute](https://github.com/rust-lang/rustfmt#tips), however, these cannot be used in all contexts because [custom inner attributes are unstable](https://github.com/rust-lang/rust/issues/54726)
+- New configuration option [`skip_macro_invocations`](https://rust-lang.github.io/rustfmt/?version=master&search=#skip_macro_invocations) [#5347](https://github.com/rust-lang/rustfmt/pull/5347) that can be used to globally define a single enumerated list of macro calls that rustfmt should skip formatting. rustfmt [currently also supports this via a custom tool attribute](https://github.com/rust-lang/rustfmt#tips), however, these cannot be used in all contexts because [custom inner attributes are unstable](https://github.com/rust-lang/rust/issues/54726)
 
 ### Misc
 
diff --git a/rust-toolchain b/rust-toolchain
@@ -1,3 +1,3 @@
 [toolchain]
-channel = "nightly-2024-06-13"
+channel = "nightly-2024-06-25"
 components = ["llvm-tools", "rustc-dev"]
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -256,7 +256,7 @@ impl Config {
     /// one.
     pub(super) fn from_resolved_toml_path(dir: &Path) -> Result<(Config, Option<PathBuf>), Error> {
         /// Try to find a project file in the given directory and its parents.
-        /// Returns the path of a the nearest project file if one exists,
+        /// Returns the path of the nearest project file if one exists,
         /// or `None` if no project file was found.
         fn resolve_project_file(dir: &Path) -> Result<Option<PathBuf>, Error> {
             let mut current = if dir.is_relative() {
diff --git a/src/expr.rs b/src/expr.rs
@@ -1860,7 +1860,11 @@ fn rewrite_let(
     // TODO(ytmimi) comments could appear between `let` and the `pat`
 
     // 4 = "let ".len()
-    let pat_shape = shape.offset_left(4)?;
+    let mut pat_shape = shape.offset_left(4)?;
+    if context.config.version() == Version::Two {
+        // 2 to account for the length of " ="
+        pat_shape = pat_shape.sub_width(2)?;
+    }
     let pat_str = pat.rewrite(context, pat_shape)?;
     result.push_str(&pat_str);
 
diff --git a/src/items.rs b/src/items.rs
@@ -1994,7 +1994,6 @@ fn rewrite_static(
     static_parts: &StaticParts<'_>,
     offset: Indent,
 ) -> Option<String> {
-    println!("rewriting static");
     let colon = colon_spaces(context.config);
     let mut prefix = format!(
         "{}{}{}{} {}{}{}",
diff --git a/src/overflow.rs b/src/overflow.rs
@@ -83,6 +83,7 @@ pub(crate) enum OverflowableItem<'a> {
     TuplePatField(&'a TuplePatField<'a>),
     Ty(&'a ast::Ty),
     Pat(&'a ast::Pat),
+    PreciseCapturingArg(&'a ast::PreciseCapturingArg),
 }
 
 impl<'a> Rewrite for OverflowableItem<'a> {
@@ -123,6 +124,7 @@ impl<'a> OverflowableItem<'a> {
             OverflowableItem::TuplePatField(pat) => f(*pat),
             OverflowableItem::Ty(ty) => f(*ty),
             OverflowableItem::Pat(pat) => f(*pat),
+            OverflowableItem::PreciseCapturingArg(arg) => f(*arg),
         }
     }
 
@@ -137,6 +139,9 @@ impl<'a> OverflowableItem<'a> {
                     matches!(meta_item.kind, ast::MetaItemKind::Word)
                 }
             },
+            // FIXME: Why don't we consider `SegmentParam` to be simple?
+            // FIXME: If we also fix `SegmentParam`, then we should apply the same
+            // heuristic to `PreciseCapturingArg`.
             _ => false,
         }
     }
@@ -244,7 +249,15 @@ macro_rules! impl_into_overflowable_item_for_rustfmt_types {
     }
 }
 
-impl_into_overflowable_item_for_ast_node!(Expr, GenericParam, NestedMetaItem, FieldDef, Ty, Pat);
+impl_into_overflowable_item_for_ast_node!(
+    Expr,
+    GenericParam,
+    NestedMetaItem,
+    FieldDef,
+    Ty,
+    Pat,
+    PreciseCapturingArg
+);
 impl_into_overflowable_item_for_rustfmt_types!([MacroArg], [SegmentParam, TuplePatField]);
 
 pub(crate) fn into_overflowable_list<'a, T>(
diff --git a/src/parse/macros/cfg_if.rs b/src/parse/macros/cfg_if.rs
@@ -67,7 +67,7 @@ fn parse_cfg_if_inner<'a>(
                 Ok(None) => continue,
                 Err(err) => {
                     err.cancel();
-                    parser.psess.dcx.reset_err_count();
+                    parser.psess.dcx().reset_err_count();
                     return Err(
                         "Expected item inside cfg_if block, but failed to parse it as an item",
                     );
diff --git a/src/parse/macros/lazy_static.rs b/src/parse/macros/lazy_static.rs
@@ -16,22 +16,21 @@ pub(crate) fn parse_lazy_static(
         ($method:ident $(,)* $($arg:expr),* $(,)*) => {
             match parser.$method($($arg,)*) {
                 Ok(val) => {
-                    if parser.psess.dcx.has_errors().is_some() {
-                        parser.psess.dcx.reset_err_count();
+                    if parser.psess.dcx().has_errors().is_some() {
+                        parser.psess.dcx().reset_err_count();
                         return None;
                     } else {
                         val
                     }
                 }
                 Err(err) => {
                     err.cancel();
-                    parser.psess.dcx.reset_err_count();
+                    parser.psess.dcx().reset_err_count();
                     return None;
                 }
             }
         }
     }
-
     while parser.token.kind != TokenKind::Eof {
         // Parse a `lazy_static!` item.
         let vis = parse_or!(parse_visibility, rustc_parse::parser::FollowedByType::No);
diff --git a/src/parse/macros/mod.rs b/src/parse/macros/mod.rs
@@ -1,4 +1,4 @@
-use rustc_ast::token::{Delimiter, NonterminalKind, TokenKind};
+use rustc_ast::token::{Delimiter, NonterminalKind, NtExprKind::*, NtPatKind::*, TokenKind};
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{ast, ptr};
 use rustc_parse::parser::{ForceCollect, Parser, Recovery};
@@ -29,8 +29,8 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
             if Parser::nonterminal_may_begin_with($nt_kind, &cloned_parser.token) {
                 match $try_parse(&mut cloned_parser) {
                     Ok(x) => {
-                        if parser.psess.dcx.has_errors().is_some() {
-                            parser.psess.dcx.reset_err_count();
+                        if parser.psess.dcx().has_errors().is_some() {
+                            parser.psess.dcx().reset_err_count();
                         } else {
                             // Parsing succeeded.
                             *parser = cloned_parser;
@@ -39,7 +39,7 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
                     }
                     Err(e) => {
                         e.cancel();
-                        parser.psess.dcx.reset_err_count();
+                        parser.psess.dcx().reset_err_count();
                     }
                 }
             }
@@ -48,7 +48,7 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
 
     parse_macro_arg!(
         Expr,
-        NonterminalKind::Expr,
+        NonterminalKind::Expr(Expr),
         |parser: &mut Parser<'b>| parser.parse_expr(),
         |x: ptr::P<ast::Expr>| Some(x)
     );
@@ -60,7 +60,7 @@ fn parse_macro_arg<'a, 'b: 'a>(parser: &'a mut Parser<'b>) -> Option<MacroArg> {
     );
     parse_macro_arg!(
         Pat,
-        NonterminalKind::PatParam { inferred: false },
+        NonterminalKind::Pat(PatParam { inferred: false }),
         |parser: &mut Parser<'b>| parser.parse_pat_no_top_alt(None, None),
         |x: ptr::P<ast::Pat>| Some(x)
     );
diff --git a/src/parse/session.rs b/src/parse/session.rs
@@ -210,7 +210,9 @@ impl ParseSess {
             rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),
             false,
         );
-        self.raw_psess.dcx.make_silent(fallback_bundle, None, false);
+        self.raw_psess
+            .dcx()
+            .make_silent(fallback_bundle, None, false);
     }
 
     pub(crate) fn span_to_filename(&self, span: Span) -> FileName {
@@ -286,11 +288,11 @@ impl ParseSess {
     }
 
     pub(super) fn has_errors(&self) -> bool {
-        self.raw_psess.dcx.has_errors().is_some()
+        self.raw_psess.dcx().has_errors().is_some()
     }
 
     pub(super) fn reset_errors(&self) {
-        self.raw_psess.dcx.reset_err_count();
+        self.raw_psess.dcx().reset_err_count();
     }
 }
 
diff --git a/src/spanned.rs b/src/spanned.rs
@@ -181,6 +181,7 @@ impl Spanned for ast::GenericBound {
         match *self {
             ast::GenericBound::Trait(ref ptr, _) => ptr.span,
             ast::GenericBound::Outlives(ref l) => l.ident.span,
+            ast::GenericBound::Use(_, span) => span,
         }
     }
 }
@@ -202,3 +203,12 @@ impl Spanned for ast::NestedMetaItem {
         self.span()
     }
 }
+
+impl Spanned for ast::PreciseCapturingArg {
+    fn span(&self) -> Span {
+        match self {
+            ast::PreciseCapturingArg::Lifetime(lt) => lt.ident.span,
+            ast::PreciseCapturingArg::Arg(path, _) => path.span,
+        }
+    }
+}
diff --git a/src/types.rs b/src/types.rs
@@ -177,6 +177,17 @@ impl<'a> Rewrite for SegmentParam<'a> {
     }
 }
 
+impl Rewrite for ast::PreciseCapturingArg {
+    fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
+        match self {
+            ast::PreciseCapturingArg::Lifetime(lt) => lt.rewrite(context, shape),
+            ast::PreciseCapturingArg::Arg(p, _) => {
+                rewrite_path(context, PathContext::Type, &None, p, shape)
+            }
+        }
+    }
+}
+
 impl Rewrite for ast::AssocItemConstraint {
     fn rewrite(&self, context: &RewriteContext<'_>, shape: Shape) -> Option<String> {
         use ast::AssocItemConstraintKind::{Bound, Equality};
@@ -564,6 +575,9 @@ impl Rewrite for ast::GenericBound {
                     .map(|s| format!("{constness}{asyncness}{polarity}{s}"))
                     .map(|s| if has_paren { format!("({})", s) } else { s })
             }
+            ast::GenericBound::Use(ref args, span) => {
+                overflow::rewrite_with_angle_brackets(context, "use", args.iter(), shape, span)
+            }
             ast::GenericBound::Outlives(ref lifetime) => lifetime.rewrite(context, shape),
         }
     }
@@ -847,11 +861,7 @@ impl Rewrite for ast::Ty {
                 rewrite_macro(mac, None, context, shape, MacroPosition::Expression)
             }
             ast::TyKind::ImplicitSelf => Some(String::from("")),
-            ast::TyKind::ImplTrait(_, ref it, ref captures) => {
-                // FIXME(precise_capturing): Implement formatting.
-                if captures.is_some() {
-                    return None;
-                }
+            ast::TyKind::ImplTrait(_, ref it) => {
                 // Empty trait is not a parser error.
                 if it.is_empty() {
                     return Some("impl".to_owned());
@@ -935,7 +945,7 @@ fn rewrite_bare_fn(
 fn is_generic_bounds_in_order(generic_bounds: &[ast::GenericBound]) -> bool {
     let is_trait = |b: &ast::GenericBound| match b {
         ast::GenericBound::Outlives(..) => false,
-        ast::GenericBound::Trait(..) => true,
+        ast::GenericBound::Trait(..) | ast::GenericBound::Use(..) => true,
     };
     let is_lifetime = |b: &ast::GenericBound| !is_trait(b);
     let last_trait_index = generic_bounds.iter().rposition(is_trait);
@@ -969,7 +979,8 @@ fn join_bounds_inner(
     let generic_bounds_in_order = is_generic_bounds_in_order(items);
     let is_bound_extendable = |s: &str, b: &ast::GenericBound| match b {
         ast::GenericBound::Outlives(..) => true,
-        ast::GenericBound::Trait(..) => last_line_extendable(s),
+        // We treat `use<>` like a trait bound here.
+        ast::GenericBound::Trait(..) | ast::GenericBound::Use(..) => last_line_extendable(s),
     };
 
     // Whether a GenericBound item is a PathSegment segment that includes internal array
@@ -991,6 +1002,7 @@ fn join_bounds_inner(
                 }
             }
         }
+        ast::GenericBound::Use(args, _) => args.len() > 1,
         _ => false,
     };
 
@@ -1114,8 +1126,7 @@ fn join_bounds_inner(
 
 pub(crate) fn opaque_ty(ty: &Option<ptr::P<ast::Ty>>) -> Option<&ast::GenericBounds> {
     ty.as_ref().and_then(|t| match &t.kind {
-        // FIXME(precise_capturing): Implement support here
-        ast::TyKind::ImplTrait(_, bounds, _) => Some(bounds),
+        ast::TyKind::ImplTrait(_, bounds) => Some(bounds),
         _ => None,
     })
 }
diff --git a/tests/source/issue-6202/issue_example.rs b/tests/source/issue-6202/issue_example.rs
@@ -0,0 +1,13 @@
+// rustfmt-max_width: 120
+// rustfmt-version: Two
+
+impl EarlyLintPass for NeedlessContinue {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::Loop(body, label, ..) | ExprKind::While(_, body, label) | ExprKind::ForLoop { body, label, .. } =  
+            &expr.kind
+            && !in_external_macro(cx.sess, expr.span)
+        {
+            check_final_block_stmt(cx, body, label, expr.span.ctxt());
+        }
+    }
+}
diff --git a/tests/source/precise-capturing.rs b/tests/source/precise-capturing.rs
@@ -0,0 +1,9 @@
+fn hello() -> impl
+use<'a> + Sized {}
+
+fn all_three() -> impl Sized + use<'a> + 'a;
+
+fn pathological() -> impl use<'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a,
+'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a,
+'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 
+'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a, 'a> + Sized {}
diff --git a/tests/target/issue-6202/issue_example.rs b/tests/target/issue-6202/issue_example.rs
@@ -0,0 +1,14 @@
+// rustfmt-max_width: 120
+// rustfmt-version: Two
+
+impl EarlyLintPass for NeedlessContinue {
+    fn check_expr(&mut self, cx: &EarlyContext<'_>, expr: &Expr) {
+        if let ExprKind::Loop(body, label, ..)
+        | ExprKind::While(_, body, label)
+        | ExprKind::ForLoop { body, label, .. } = &expr.kind
+            && !in_external_macro(cx.sess, expr.span)
+        {
+            check_final_block_stmt(cx, body, label, expr.span.ctxt());
+        }
+    }
+}
diff --git a/tests/target/precise-capturing.rs b/tests/target/precise-capturing.rs
@@ -0,0 +1,55 @@
+fn hello() -> impl use<'a> + Sized {}
+
+fn all_three() -> impl Sized + use<'a> + 'a;
+
+fn pathological() -> impl use<
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+    'a,
+> + Sized {
+}

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ pub(crate) enum OverflowableItem<'a> {`
`83`	`83`	`TuplePatField(&'a TuplePatField<'a>),`
`84`	`84`	`Ty(&'a ast::Ty),`
`85`	`85`	`Pat(&'a ast::Pat),`
	`86`	`+ PreciseCapturingArg(&'a ast::PreciseCapturingArg),`
`86`	`87`	`}`
`87`	`88`
`88`	`89`	`impl<'a> Rewrite for OverflowableItem<'a> {`
`@@ -123,6 +124,7 @@ impl<'a> OverflowableItem<'a> {`
`123`	`124`	`OverflowableItem::TuplePatField(pat) => f(*pat),`
`124`	`125`	`OverflowableItem::Ty(ty) => f(*ty),`
`125`	`126`	`OverflowableItem::Pat(pat) => f(*pat),`
	`127`	`+ OverflowableItem::PreciseCapturingArg(arg) => f(*arg),`
`126`	`128`	`}`
`127`	`129`	`}`
`128`	`130`
`@@ -137,6 +139,9 @@ impl<'a> OverflowableItem<'a> {`
`137`	`139`	`matches!(meta_item.kind, ast::MetaItemKind::Word)`
`138`	`140`	`}`
`139`	`141`	`},`
	`142`	+ // FIXME: Why don't we consider `SegmentParam` to be simple?
	`143`	+ // FIXME: If we also fix `SegmentParam`, then we should apply the same
	`144`	+ // heuristic to `PreciseCapturingArg`.
`140`	`145`	`_ => false,`
`141`	`146`	`}`
`142`	`147`	`}`
`@@ -244,7 +249,15 @@ macro_rules! impl_into_overflowable_item_for_rustfmt_types {`
`244`	`249`	`}`
`245`	`250`	`}`
`246`	`251`
`247`		`-impl_into_overflowable_item_for_ast_node!(Expr, GenericParam, NestedMetaItem, FieldDef, Ty, Pat);`
	`252`	`+impl_into_overflowable_item_for_ast_node!(`
	`253`	`+ Expr,`
	`254`	`+ GenericParam,`
	`255`	`+ NestedMetaItem,`
	`256`	`+ FieldDef,`
	`257`	`+ Ty,`
	`258`	`+ Pat,`
	`259`	`+ PreciseCapturingArg`
	`260`	`+);`
`248`	`261`	`impl_into_overflowable_item_for_rustfmt_types!([MacroArg], [SegmentParam, TuplePatField]);`
`249`	`262`
`250`	`263`	`pub(crate) fn into_overflowable_list<'a, T>(`
Original file line number	Diff line number	Diff line change
`@@ -16,22 +16,21 @@ pub(crate) fn parse_lazy_static(`
`16`	`16`	`($method:ident $(,)* $($arg:expr),* $(,)*) => {`
`17`	`17`	`match parser.$method($($arg,)*) {`
`18`	`18`	`Ok(val) => {`
`19`		`- if parser.psess.dcx.has_errors().is_some() {`
`20`		`- parser.psess.dcx.reset_err_count();`
	`19`	`+ if parser.psess.dcx().has_errors().is_some() {`
	`20`	`+ parser.psess.dcx().reset_err_count();`
`21`	`21`	`return None;`
`22`	`22`	`} else {`
`23`	`23`	`val`
`24`	`24`	`}`
`25`	`25`	`}`
`26`	`26`	`Err(err) => {`
`27`	`27`	`err.cancel();`
`28`		`- parser.psess.dcx.reset_err_count();`
	`28`	`+ parser.psess.dcx().reset_err_count();`
`29`	`29`	`return None;`
`30`	`30`	`}`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
`34`		`-`
`35`	`34`	`while parser.token.kind != TokenKind::Eof {`
`36`	`35`	// Parse a `lazy_static!` item.
`37`	`36`	`let vis = parse_or!(parse_visibility, rustc_parse::parser::FollowedByType::No);`
Original file line number	Diff line number	Diff line change
`@@ -210,7 +210,9 @@ impl ParseSess {`
`210`	`210`	`rustc_driver::DEFAULT_LOCALE_RESOURCES.to_vec(),`
`211`	`211`	`false,`
`212`	`212`	`);`
`213`		`- self.raw_psess.dcx.make_silent(fallback_bundle, None, false);`
	`213`	`+ self.raw_psess`
	`214`	`+ .dcx()`
	`215`	`+ .make_silent(fallback_bundle, None, false);`
`214`	`216`	`}`
`215`	`217`
`216`	`218`	`pub(crate) fn span_to_filename(&self, span: Span) -> FileName {`
`@@ -286,11 +288,11 @@ impl ParseSess {`
`286`	`288`	`}`
`287`	`289`
`288`	`290`	`pub(super) fn has_errors(&self) -> bool {`
`289`		`- self.raw_psess.dcx.has_errors().is_some()`
	`291`	`+ self.raw_psess.dcx().has_errors().is_some()`
`290`	`292`	`}`
`291`	`293`
`292`	`294`	`pub(super) fn reset_errors(&self) {`
`293`		`- self.raw_psess.dcx.reset_err_count();`
	`295`	`+ self.raw_psess.dcx().reset_err_count();`
`294`	`296`	`}`
`295`	`297`	`}`
`296`	`298`