Rollup merge of #123926 - compiler-errors:no-ann, r=estebank

fmease · web-flow · commit 1069ad398258 · 2024-04-16T01:12:38.000+02:00
Fix pretty HIR for anon consts in diagnostics

This removes the `NoAnn` printer which skips over nested bodies altogether, which is confusing, and requires users of `{ty|qpath|pat}_to_string` to pass in `&amp;tcx` which now impleemnts `hir_pretty::PpAnn`.

There's one case where this "regresses" by actually printing out the body of the anon const -- we could suppress that, but I don't expect people to actually get anon consts like that unless they're fuzzing, tbh.

r? estebank
diff --git a/Cargo.lock b/Cargo.lock
@@ -4278,6 +4278,7 @@ dependencies = [
  "rustc_fluent_macro",
  "rustc_graphviz",
  "rustc_hir",
+ "rustc_hir_pretty",
  "rustc_index",
  "rustc_macros",
  "rustc_query_system",
diff --git a/compiler/rustc_driver_impl/src/pretty.rs b/compiler/rustc_driver_impl/src/pretty.rs
@@ -24,20 +24,6 @@ struct AstNoAnn;
 
 impl pprust_ast::PpAnn for AstNoAnn {}
 
-struct HirNoAnn<'tcx> {
-    tcx: TyCtxt<'tcx>,
-}
-
-impl<'tcx> pprust_hir::PpAnn for HirNoAnn<'tcx> {
-    fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
-        pprust_hir::PpAnn::nested(
-            &(&self.tcx.hir() as &dyn hir::intravisit::Map<'_>),
-            state,
-            nested,
-        )
-    }
-}
-
 struct AstIdentifiedAnn;
 
 impl pprust_ast::PpAnn for AstIdentifiedAnn {
@@ -300,10 +286,7 @@ pub fn print<'tcx>(sess: &Session, ppm: PpMode, ex: PrintExtra<'tcx>) {
                 )
             };
             match s {
-                PpHirMode::Normal => {
-                    let annotation = HirNoAnn { tcx };
-                    f(&annotation)
-                }
+                PpHirMode::Normal => f(&tcx),
                 PpHirMode::Identified => {
                     let annotation = HirIdentifiedAnn { tcx };
                     f(&annotation)
diff --git a/compiler/rustc_hir_analysis/src/check/errs.rs b/compiler/rustc_hir_analysis/src/check/errs.rs
@@ -12,7 +12,7 @@ pub fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {
     let hir_id = expr.hir_id;
     if let hir::ExprKind::AddrOf(borrow_kind, m, expr) = expr.kind
         && matches!(borrow_kind, hir::BorrowKind::Ref)
-        && let Some(var) = is_path_static_mut(*expr)
+        && let Some(var) = path_if_static_mut(tcx, expr)
     {
         handle_static_mut_ref(tcx, span, var, span.edition().at_least_rust_2024(), m, hir_id);
     }
@@ -24,7 +24,7 @@ pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {
         && let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind
         && let hir::ByRef::Yes(rmutbl) = ba.0
         && let Some(init) = loc.init
-        && let Some(var) = is_path_static_mut(*init)
+        && let Some(var) = path_if_static_mut(tcx, init)
     {
         handle_static_mut_ref(
             tcx,
@@ -37,13 +37,13 @@ pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {
     }
 }
 
-fn is_path_static_mut(expr: hir::Expr<'_>) -> Option<String> {
+fn path_if_static_mut(tcx: TyCtxt<'_>, expr: &hir::Expr<'_>) -> Option<String> {
     if let hir::ExprKind::Path(qpath) = expr.kind
         && let hir::QPath::Resolved(_, path) = qpath
         && let hir::def::Res::Def(def_kind, _) = path.res
         && let hir::def::DefKind::Static { mutability: Mutability::Mut, nested: false } = def_kind
     {
-        return Some(qpath_to_string(&qpath));
+        return Some(qpath_to_string(&tcx, &qpath));
     }
     None
 }
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -49,10 +49,6 @@ pub trait PpAnn {
     fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}
 }
 
-pub struct NoAnn;
-
-impl PpAnn for NoAnn {}
-
 impl PpAnn for &dyn rustc_hir::intravisit::Map<'_> {
     fn nested(&self, state: &mut State<'_>, nested: Nested) {
         match nested {
@@ -190,16 +186,16 @@ where
     printer.s.eof()
 }
 
-pub fn ty_to_string(ty: &hir::Ty<'_>) -> String {
-    to_string(&NoAnn, |s| s.print_type(ty))
+pub fn ty_to_string(ann: &dyn PpAnn, ty: &hir::Ty<'_>) -> String {
+    to_string(ann, |s| s.print_type(ty))
 }
 
-pub fn qpath_to_string(segment: &hir::QPath<'_>) -> String {
-    to_string(&NoAnn, |s| s.print_qpath(segment, false))
+pub fn qpath_to_string(ann: &dyn PpAnn, segment: &hir::QPath<'_>) -> String {
+    to_string(ann, |s| s.print_qpath(segment, false))
 }
 
-pub fn pat_to_string(pat: &hir::Pat<'_>) -> String {
-    to_string(&NoAnn, |s| s.print_pat(pat))
+pub fn pat_to_string(ann: &dyn PpAnn, pat: &hir::Pat<'_>) -> String {
+    to_string(ann, |s| s.print_pat(pat))
 }
 
 impl<'a> State<'a> {
diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
@@ -392,7 +392,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     return self.get_fn_decl(hir_id).map(|(_, fn_decl, _)| {
                         let (ty, span) = match fn_decl.output {
                             hir::FnRetTy::DefaultReturn(span) => ("()".to_string(), span),
-                            hir::FnRetTy::Return(ty) => (ty_to_string(ty), ty.span),
+                            hir::FnRetTy::Return(ty) => (ty_to_string(&self.tcx, ty), ty.span),
                         };
                         (span, format!("expected `{ty}` because of this return type"))
                     });
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
@@ -714,7 +714,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 def::CtorOf::Variant => "enum variant",
             };
             let removal_span = callee_expr.span.shrink_to_hi().to(call_expr.span.shrink_to_hi());
-            unit_variant = Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(qpath)));
+            unit_variant =
+                Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(&self.tcx, qpath)));
         }
 
         let callee_ty = self.resolve_vars_if_possible(callee_ty);
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
@@ -365,7 +365,7 @@ fn report_unexpected_variant_res(
         Res::Def(DefKind::Variant, _) => "struct variant",
         _ => res.descr(),
     };
-    let path_str = rustc_hir_pretty::qpath_to_string(qpath);
+    let path_str = rustc_hir_pretty::qpath_to_string(&tcx, qpath);
     let err = tcx
         .dcx()
         .struct_span_err(span, format!("expected {expected}, found {res_descr} `{path_str}`"))
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
@@ -1556,7 +1556,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         {
             let has_shorthand_field_name = field_patterns.iter().any(|field| field.is_shorthand);
             if has_shorthand_field_name {
-                let path = rustc_hir_pretty::qpath_to_string(qpath);
+                let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);
                 let mut err = struct_span_code_err!(
                     self.dcx(),
                     pat.span,
@@ -1738,7 +1738,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 return None;
             }
 
-            let path = rustc_hir_pretty::qpath_to_string(qpath);
+            let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);
             let mut err = struct_span_code_err!(
                 self.dcx(),
                 pat.span,
@@ -1788,7 +1788,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             f
                         }
                     }
-                    Err(_) => rustc_hir_pretty::pat_to_string(field.pat),
+                    Err(_) => rustc_hir_pretty::pat_to_string(&self.tcx, field.pat),
                 }
             })
             .collect::<Vec<String>>()
diff --git a/compiler/rustc_middle/Cargo.toml b/compiler/rustc_middle/Cargo.toml
@@ -25,6 +25,7 @@ rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_graphviz = { path = "../rustc_graphviz" }
 rustc_hir = { path = "../rustc_hir" }
+rustc_hir_pretty = { path = "../rustc_hir_pretty" }
 rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_query_system = { path = "../rustc_query_system" }
diff --git a/compiler/rustc_middle/src/hir/map/mod.rs b/compiler/rustc_middle/src/hir/map/mod.rs
@@ -13,6 +13,7 @@ use rustc_hir::def_id::{DefId, LocalDefId, LocalModDefId, LOCAL_CRATE};
 use rustc_hir::definitions::{DefKey, DefPath, DefPathHash};
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::*;
+use rustc_hir_pretty as pprust_hir;
 use rustc_middle::hir::nested_filter;
 use rustc_span::def_id::StableCrateId;
 use rustc_span::symbol::{kw, sym, Ident, Symbol};
@@ -999,6 +1000,12 @@ impl<'hir> intravisit::Map<'hir> for Map<'hir> {
     }
 }
 
+impl<'tcx> pprust_hir::PpAnn for TyCtxt<'tcx> {
+    fn nested(&self, state: &mut pprust_hir::State<'_>, nested: pprust_hir::Nested) {
+        pprust_hir::PpAnn::nested(&(&self.hir() as &dyn intravisit::Map<'_>), state, nested)
+    }
+}
+
 pub(super) fn crate_hash(tcx: TyCtxt<'_>, _: LocalCrate) -> Svh {
     let krate = tcx.hir_crate(());
     let hir_body_hash = krate.opt_hir_hash.expect("HIR hash missing while computing crate hash");
diff --git a/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -77,7 +77,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
 
         let (help, final_suggestion) = if let Some(method) = omit_cast.corresponding_item() {
             // don't force absolute path
-            let method = qpath_to_string(method);
+            let method = qpath_to_string(&cx.tcx, method);
             ("try call directly", format!("{method}{turbofish}()"))
         } else {
             let cast_expr_sugg = Sugg::hir_with_applicability(cx, cast_expr, "_", &mut app);
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs b/src/tools/clippy/clippy_lints/src/matches/match_wild_err_arm.rs
@@ -19,7 +19,7 @@ pub(crate) fn check<'tcx>(cx: &LateContext<'tcx>, ex: &Expr<'tcx>, arms: &[Arm<'
     if is_type_diagnostic_item(cx, ex_ty, sym::Result) {
         for arm in arms {
             if let PatKind::TupleStruct(ref path, inner, _) = arm.pat.kind {
-                let path_str = rustc_hir_pretty::qpath_to_string(path);
+                let path_str = rustc_hir_pretty::qpath_to_string(&cx.tcx, path);
                 if path_str == "Err" {
                     let mut matching_wild = inner.iter().any(is_wild);
                     let mut ident_bind_name = kw::Underscore;
diff --git a/src/tools/clippy/clippy_lints/src/mut_reference.rs b/src/tools/clippy/clippy_lints/src/mut_reference.rs
@@ -49,7 +49,7 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                         cx,
                         arguments.iter().collect(),
                         cx.typeck_results().expr_ty(fn_expr),
-                        &rustc_hir_pretty::qpath_to_string(path),
+                        &rustc_hir_pretty::qpath_to_string(&cx.tcx, path),
                         "function",
                     );
                 }
diff --git a/tests/ui/consts/value-suggestion-ice-123906.stderr b/tests/ui/consts/value-suggestion-ice-123906.stderr
@@ -2,7 +2,7 @@ error[E0308]: mismatched types
   --> $DIR/value-suggestion-ice-123906.rs:3:9
    |
 LL | fn as_chunks<const N: usize>() -> [u8; N] {
-   |                                   ------- expected `[u8; ]` because of this return type
+   |                                   ------- expected `[u8; N]` because of this return type
 LL |     loop {
    |     ---- this loop is expected to be of type `[u8; N]`
 LL |         break;
diff --git a/tests/ui/enum/error-variant-with-turbofishes.rs b/tests/ui/enum/error-variant-with-turbofishes.rs
@@ -0,0 +1,8 @@
+enum Struct<const N: usize> { Variant { x: [(); N] } }
+
+fn test() {
+    let x = Struct::<0>::Variant;
+    //~^ ERROR expected value, found struct variant `Struct<0>::Variant`
+}
+
+fn main() {}
diff --git a/tests/ui/enum/error-variant-with-turbofishes.stderr b/tests/ui/enum/error-variant-with-turbofishes.stderr
@@ -0,0 +1,9 @@
+error[E0533]: expected value, found struct variant `Struct<0>::Variant`
+  --> $DIR/error-variant-with-turbofishes.rs:4:13
+   |
+LL |     let x = Struct::<0>::Variant;
+   |             ^^^^^^^^^^^^^^^^^^^^ not a value
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0533`.
diff --git a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs
@@ -3,5 +3,5 @@ fn main() {
 //~^ ERROR expected a pattern, found an expression
 //~| ERROR cannot find type `T` in this scope
 //~| ERROR const and type arguments are not allowed on builtin type `str`
-//~| ERROR expected unit struct, unit variant or constant, found associated function `str<, T>::as_bytes`
+//~| ERROR expected unit struct, unit variant or constant, found associated function `str<
 }
diff --git a/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr b/tests/ui/sized/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.stderr
@@ -24,7 +24,9 @@ LL -     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;
 LL +     let str::as_bytes;
    |
 
-error[E0533]: expected unit struct, unit variant or constant, found associated function `str<, T>::as_bytes`
+error[E0533]: expected unit struct, unit variant or constant, found associated function `str<{
+                      fn str() { let (/*ERROR*/); }
+                  }, T>::as_bytes`
   --> $DIR/ensure-overriding-bindings-in-pattern-with-ty-err-doesnt-ice.rs:2:9
    |
 LL |     let str::<{fn str() { let str::T>>::as_bytes; }}, T>::as_bytes;

Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ pub fn maybe_expr_static_mut(tcx: TyCtxt<'_>, expr: hir::Expr<'_>) {`
`12`	`12`	`let hir_id = expr.hir_id;`
`13`	`13`	`if let hir::ExprKind::AddrOf(borrow_kind, m, expr) = expr.kind`
`14`	`14`	`&& matches!(borrow_kind, hir::BorrowKind::Ref)`
`15`		`- && let Some(var) = is_path_static_mut(*expr)`
	`15`	`+ && let Some(var) = path_if_static_mut(tcx, expr)`
`16`	`16`	`{`
`17`	`17`	`handle_static_mut_ref(tcx, span, var, span.edition().at_least_rust_2024(), m, hir_id);`
`18`	`18`	`}`
`@@ -24,7 +24,7 @@ pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {`
`24`	`24`	`&& let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind`
`25`	`25`	`&& let hir::ByRef::Yes(rmutbl) = ba.0`
`26`	`26`	`&& let Some(init) = loc.init`
`27`		`- && let Some(var) = is_path_static_mut(*init)`
	`27`	`+ && let Some(var) = path_if_static_mut(tcx, init)`
`28`	`28`	`{`
`29`	`29`	`handle_static_mut_ref(`
`30`	`30`	`tcx,`
`@@ -37,13 +37,13 @@ pub fn maybe_stmt_static_mut(tcx: TyCtxt<'_>, stmt: hir::Stmt<'_>) {`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-fn is_path_static_mut(expr: hir::Expr<'_>) -> Option<String> {`
	`40`	`+fn path_if_static_mut(tcx: TyCtxt<'_>, expr: &hir::Expr<'_>) -> Option<String> {`
`41`	`41`	`if let hir::ExprKind::Path(qpath) = expr.kind`
`42`	`42`	`&& let hir::QPath::Resolved(_, path) = qpath`
`43`	`43`	`&& let hir::def::Res::Def(def_kind, _) = path.res`
`44`	`44`	`&& let hir::def::DefKind::Static { mutability: Mutability::Mut, nested: false } = def_kind`
`45`	`45`	`{`
`46`		`- return Some(qpath_to_string(&qpath));`
	`46`	`+ return Some(qpath_to_string(&tcx, &qpath));`
`47`	`47`	`}`
`48`	`48`	`None`
`49`	`49`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,10 +49,6 @@ pub trait PpAnn {`
`49`	`49`	`fn post(&self, _state: &mut State<'_>, _node: AnnNode<'_>) {}`
`50`	`50`	`}`
`51`	`51`
`52`		`-pub struct NoAnn;`
`53`		`-`
`54`		`-impl PpAnn for NoAnn {}`
`55`		`-`
`56`	`52`	`impl PpAnn for &dyn rustc_hir::intravisit::Map<'_> {`
`57`	`53`	`fn nested(&self, state: &mut State<'_>, nested: Nested) {`
`58`	`54`	`match nested {`
`@@ -190,16 +186,16 @@ where`
`190`	`186`	`printer.s.eof()`
`191`	`187`	`}`
`192`	`188`
`193`		`-pub fn ty_to_string(ty: &hir::Ty<'_>) -> String {`
`194`		`- to_string(&NoAnn, \|s\| s.print_type(ty))`
	`189`	`+pub fn ty_to_string(ann: &dyn PpAnn, ty: &hir::Ty<'_>) -> String {`
	`190`	`+ to_string(ann, \|s\| s.print_type(ty))`
`195`	`191`	`}`
`196`	`192`
`197`		`-pub fn qpath_to_string(segment: &hir::QPath<'_>) -> String {`
`198`		`- to_string(&NoAnn, \|s\| s.print_qpath(segment, false))`
	`193`	`+pub fn qpath_to_string(ann: &dyn PpAnn, segment: &hir::QPath<'_>) -> String {`
	`194`	`+ to_string(ann, \|s\| s.print_qpath(segment, false))`
`199`	`195`	`}`
`200`	`196`
`201`		`-pub fn pat_to_string(pat: &hir::Pat<'_>) -> String {`
`202`		`- to_string(&NoAnn, \|s\| s.print_pat(pat))`
	`197`	`+pub fn pat_to_string(ann: &dyn PpAnn, pat: &hir::Pat<'_>) -> String {`
	`198`	`+ to_string(ann, \|s\| s.print_pat(pat))`
`203`	`199`	`}`
`204`	`200`
`205`	`201`	`impl<'a> State<'a> {`
Original file line number	Diff line number	Diff line change
`@@ -714,7 +714,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`714`	`714`	`def::CtorOf::Variant => "enum variant",`
`715`	`715`	`};`
`716`	`716`	`let removal_span = callee_expr.span.shrink_to_hi().to(call_expr.span.shrink_to_hi());`
`717`		`- unit_variant = Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(qpath)));`
	`717`	`+ unit_variant =`
	`718`	`+ Some((removal_span, descr, rustc_hir_pretty::qpath_to_string(&self.tcx, qpath)));`
`718`	`719`	`}`
`719`	`720`
`720`	`721`	`let callee_ty = self.resolve_vars_if_possible(callee_ty);`
Original file line number	Diff line number	Diff line change
`@@ -1556,7 +1556,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1556`	`1556`	`{`
`1557`	`1557`	`let has_shorthand_field_name = field_patterns.iter().any(\|field\| field.is_shorthand);`
`1558`	`1558`	`if has_shorthand_field_name {`
`1559`		`- let path = rustc_hir_pretty::qpath_to_string(qpath);`
	`1559`	`+ let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);`
`1560`	`1560`	`let mut err = struct_span_code_err!(`
`1561`	`1561`	`self.dcx(),`
`1562`	`1562`	`pat.span,`
`@@ -1738,7 +1738,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1738`	`1738`	`return None;`
`1739`	`1739`	`}`
`1740`	`1740`
`1741`		`- let path = rustc_hir_pretty::qpath_to_string(qpath);`
	`1741`	`+ let path = rustc_hir_pretty::qpath_to_string(&self.tcx, qpath);`
`1742`	`1742`	`let mut err = struct_span_code_err!(`
`1743`	`1743`	`self.dcx(),`
`1744`	`1744`	`pat.span,`
`@@ -1788,7 +1788,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {`
`1788`	`1788`	`f`
`1789`	`1789`	`}`
`1790`	`1790`	`}`
`1791`		`- Err(_) => rustc_hir_pretty::pat_to_string(field.pat),`
	`1791`	`+ Err(_) => rustc_hir_pretty::pat_to_string(&self.tcx, field.pat),`
`1792`	`1792`	`}`
`1793`	`1793`	`})`
`1794`	`1794`	`.collect::<Vec<String>>()`