Do not gather local all together at the beginning of typeck

24 files changed, 292 insertions, 277 deletions

diff --git a/compiler/rustc_hir_typeck/src/_match.rs b/compiler/rustc_hir_typeck/src/_match.rs
index 38319862334..2e7831f16ae 100644
--- a/compiler/rustc_hir_typeck/src/_match.rs
+++ b/compiler/rustc_hir_typeck/src/_match.rs
@@ -11,7 +11,7 @@ use rustc_trait_selection::traits::{
 use tracing::{debug, instrument};
 
 use crate::coercion::{AsCoercionSite, CoerceMany};
-use crate::{Diverges, Expectation, FnCtxt, Needs};
+use crate::{Diverges, Expectation, FnCtxt, GatherLocalsVisitor, Needs};
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     #[instrument(skip(self), level = "debug", ret)]
@@ -43,6 +43,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // #55810: Type check patterns first so we get types for all bindings.
         let scrut_span = scrut.span.find_ancestor_inside(expr.span).unwrap_or(scrut.span);
         for arm in arms {
+            GatherLocalsVisitor::gather_from_arm(self, arm);
+
             self.check_pat_top(arm.pat, scrutinee_ty, Some(scrut_span), Some(scrut), None);
         }
 
diff --git a/compiler/rustc_hir_typeck/src/check.rs b/compiler/rustc_hir_typeck/src/check.rs
index 2189fdf0f34..99103f14d68 100644
--- a/compiler/rustc_hir_typeck/src/check.rs
+++ b/compiler/rustc_hir_typeck/src/check.rs
@@ -3,7 +3,6 @@ use std::cell::RefCell;
 use rustc_abi::ExternAbi;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
-use rustc_hir::intravisit::Visitor;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir_analysis::check::check_function_signature;
 use rustc_infer::infer::RegionVariableOrigin;
@@ -50,7 +49,9 @@ pub(super) fn check_fn<'a, 'tcx>(
 
     let span = body.value.span;
 
-    GatherLocalsVisitor::new(fcx).visit_body(body);
+    for param in body.params {
+        GatherLocalsVisitor::gather_from_param(fcx, param);
+    }
 
     // C-variadic fns also have a `VaList` input that's not listed in `fn_sig`
     // (as it's created inside the body itself, not passed in from outside).
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index db2650ed357..2c28ffd1fe3 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -16,7 +16,6 @@ use rustc_errors::{
 };
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefId;
-use rustc_hir::intravisit::Visitor;
 use rustc_hir::lang_items::LangItem;
 use rustc_hir::{ExprKind, HirId, QPath};
 use rustc_hir_analysis::NoVariantNamed;
@@ -50,8 +49,8 @@ use crate::errors::{
     YieldExprOutsideOfCoroutine,
 };
 use crate::{
-    BreakableCtxt, CoroutineTypes, Diverges, FnCtxt, Needs, TupleArgumentsFlag, cast,
-    fatally_break_rust, report_unexpected_variant_res, type_error_struct,
+    BreakableCtxt, CoroutineTypes, Diverges, FnCtxt, GatherLocalsVisitor, Needs,
+    TupleArgumentsFlag, cast, fatally_break_rust, report_unexpected_variant_res, type_error_struct,
 };
 
 impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
@@ -1518,11 +1517,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let_expr: &'tcx hir::LetExpr<'tcx>,
         hir_id: HirId,
     ) -> Ty<'tcx> {
+        GatherLocalsVisitor::gather_from_let_expr(self, let_expr, hir_id);
+
         // for let statements, this is done in check_stmt
         let init = let_expr.init;
         self.warn_if_unreachable(init.hir_id, init.span, "block in `let` expression");
+
         // otherwise check exactly as a let statement
         self.check_decl((let_expr, hir_id).into());
+
         // but return a bool, for this is a boolean expression
         if let ast::Recovered::Yes(error_guaranteed) = let_expr.recovered {
             self.set_tainted_by_errors(error_guaranteed);
@@ -1827,7 +1830,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // Create a new function context.
         let def_id = block.def_id;
         let fcx = FnCtxt::new(self, self.param_env, def_id);
-        crate::GatherLocalsVisitor::new(&fcx).visit_body(body);
 
         let ty = fcx.check_expr_with_expectation(body.value, expected);
         fcx.require_type_is_sized(ty, body.value.span, ObligationCauseCode::SizedConstOrStatic);
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index c804dc5e7fb..6cc7e82bbf7 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -37,8 +37,8 @@ use crate::method::probe::IsSuggestion;
 use crate::method::probe::Mode::MethodCall;
 use crate::method::probe::ProbeScope::TraitsInScope;
 use crate::{
-    BreakableCtxt, Diverges, Expectation, FnCtxt, LoweredTy, Needs, TupleArgumentsFlag, errors,
-    struct_span_code_err,
+    BreakableCtxt, Diverges, Expectation, FnCtxt, GatherLocalsVisitor, LoweredTy, Needs,
+    TupleArgumentsFlag, errors, struct_span_code_err,
 };
 
 rustc_index::newtype_index! {
@@ -1765,6 +1765,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
     /// Type check a `let` statement.
     fn check_decl_local(&self, local: &'tcx hir::LetStmt<'tcx>) {
+        GatherLocalsVisitor::gather_from_local(self, local);
+
         let ty = self.check_decl(local.into());
         self.write_ty(local.hir_id, ty);
         if local.pat.is_never_pattern() {
diff --git a/compiler/rustc_hir_typeck/src/gather_locals.rs b/compiler/rustc_hir_typeck/src/gather_locals.rs
index 5d87e800096..a8bbc89dbde 100644
--- a/compiler/rustc_hir_typeck/src/gather_locals.rs
+++ b/compiler/rustc_hir_typeck/src/gather_locals.rs
@@ -55,6 +55,14 @@ impl<'a> From<(&'a hir::LetExpr<'a>, HirId)> for Declaration<'a> {
     }
 }
 
+/// The `GatherLocalsVisitor` is responsible for initializing local variable types
+/// in the [`ty::TypeckResults`] for all subpatterns in statements and expressions
+/// like `let`, `match`, and params of function bodies. It also adds `Sized` bounds
+/// for these types (with exceptions for unsized feature gates like `unsized_fn_params`).
+///
+/// Failure to visit locals will cause an ICE in writeback when the local's type is
+/// resolved. Visiting locals twice will ICE in the `GatherLocalsVisitor`, since it
+/// will overwrite the type previously stored in the local.
 pub(super) struct GatherLocalsVisitor<'a, 'tcx> {
     fcx: &'a FnCtxt<'a, 'tcx>,
     // parameters are special cases of patterns, but we want to handle them as
@@ -63,9 +71,37 @@ pub(super) struct GatherLocalsVisitor<'a, 'tcx> {
     outermost_fn_param_pat: Option<(Span, HirId)>,
 }
 
+// N.B. additional `gather_*` functions should be careful to only walk the pattern
+// for new expressions, since visiting sub-expressions or nested bodies may initialize
+// locals which are not conceptually owned by the gathered statement or expression.
 impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
-    pub(super) fn new(fcx: &'a FnCtxt<'a, 'tcx>) -> Self {
-        Self { fcx, outermost_fn_param_pat: None }
+    pub(crate) fn gather_from_local(fcx: &'a FnCtxt<'a, 'tcx>, local: &'tcx hir::LetStmt<'tcx>) {
+        let mut visitor = GatherLocalsVisitor { fcx, outermost_fn_param_pat: None };
+        visitor.declare(local.into());
+        visitor.visit_pat(local.pat);
+    }
+
+    pub(crate) fn gather_from_let_expr(
+        fcx: &'a FnCtxt<'a, 'tcx>,
+        let_expr: &'tcx hir::LetExpr<'tcx>,
+        expr_hir_id: hir::HirId,
+    ) {
+        let mut visitor = GatherLocalsVisitor { fcx, outermost_fn_param_pat: None };
+        visitor.declare((let_expr, expr_hir_id).into());
+        visitor.visit_pat(let_expr.pat);
+    }
+
+    pub(crate) fn gather_from_param(fcx: &'a FnCtxt<'a, 'tcx>, param: &'tcx hir::Param<'tcx>) {
+        let mut visitor = GatherLocalsVisitor {
+            fcx,
+            outermost_fn_param_pat: Some((param.ty_span, param.hir_id)),
+        };
+        visitor.visit_pat(param.pat);
+    }
+
+    pub(crate) fn gather_from_arm(fcx: &'a FnCtxt<'a, 'tcx>, local: &'tcx hir::Arm<'tcx>) {
+        let mut visitor = GatherLocalsVisitor { fcx, outermost_fn_param_pat: None };
+        visitor.visit_pat(local.pat);
     }
 
     fn assign(&mut self, span: Span, nid: HirId, ty_opt: Option<Ty<'tcx>>) -> Ty<'tcx> {
@@ -73,12 +109,12 @@ impl<'a, 'tcx> GatherLocalsVisitor<'a, 'tcx> {
             None => {
                 // Infer the variable's type.
                 let var_ty = self.fcx.next_ty_var(span);
-                self.fcx.locals.borrow_mut().insert(nid, var_ty);
+                assert_eq!(self.fcx.locals.borrow_mut().insert(nid, var_ty), None);
                 var_ty
             }
             Some(typ) => {
                 // Take type that the user specified.
-                self.fcx.locals.borrow_mut().insert(nid, typ);
+                assert_eq!(self.fcx.locals.borrow_mut().insert(nid, typ), None);
                 typ
             }
         }
@@ -133,13 +169,6 @@ impl<'a, 'tcx> Visitor<'tcx> for GatherLocalsVisitor<'a, 'tcx> {
         intravisit::walk_expr(self, expr)
     }
 
-    fn visit_param(&mut self, param: &'tcx hir::Param<'tcx>) {
-        let old_outermost_fn_param_pat =
-            self.outermost_fn_param_pat.replace((param.ty_span, param.hir_id));
-        intravisit::walk_param(self, param);
-        self.outermost_fn_param_pat = old_outermost_fn_param_pat;
-    }
-
     // Add pattern bindings.
     fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
         if let PatKind::Binding(_, _, ident, _) = p.kind {
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index d861a4f81b0..78233a34c46 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -46,7 +46,6 @@ use rustc_errors::codes::*;
 use rustc_errors::{Applicability, ErrorGuaranteed, pluralize, struct_span_code_err};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
-use rustc_hir::intravisit::Visitor;
 use rustc_hir::{HirId, HirIdMap, Node};
 use rustc_hir_analysis::check::check_abi;
 use rustc_hir_analysis::hir_ty_lowering::HirTyLowerer;
@@ -191,9 +190,6 @@ fn typeck_with_inspect<'tcx>(
         let wf_code = ObligationCauseCode::WellFormed(Some(WellFormedLoc::Ty(def_id)));
         fcx.register_wf_obligation(expected_type.into(), body.value.span, wf_code);
 
-        // Gather locals in statics (because of block expressions).
-        GatherLocalsVisitor::new(&fcx).visit_body(body);
-
         fcx.check_expr_coercible_to_type(body.value, expected_type, None);
 
         fcx.write_ty(id, expected_type);
diff --git a/tests/ui/async-await/async-closures/def-path.stderr b/tests/ui/async-await/async-closures/def-path.stderr
index 13ebaf67e54..b50e353b698 100644
--- a/tests/ui/async-await/async-closures/def-path.stderr
+++ b/tests/ui/async-await/async-closures/def-path.stderr
@@ -5,11 +5,11 @@ LL |     let x = async || {};
    |                      -- the expected `async` closure body
 LL |
 LL |     let () = x();
-   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?6t}`
+   |         ^^   --- this expression has type `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?5t}`
    |         |
    |         expected `async` closure body, found `()`
    |
-   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?6t}`
+   = note: expected `async` closure body `{static main::{closure#0}::{closure#0}<?17t> upvar_tys=?16t resume_ty=ResumeTy yield_ty=() return_ty=() witness=?5t}`
                          found unit type `()`
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr b/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
index b71cfc50333..bcf5759a194 100644
--- a/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
+++ b/tests/ui/closures/print/closure-print-generic-trim-off-verbose-2.stderr
@@ -9,7 +9,7 @@ LL |         let c1 : () = c;
    |                  expected due to this
    |
    = note: expected unit type `()`
-                found closure `{mod1::f<T>::{closure#0} closure_kind_ty=?8t closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=?7t}`
+                found closure `{mod1::f<T>::{closure#0} closure_kind_ty=?7t closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=?6t}`
 help: use parentheses to call this closure
    |
 LL |         let c1 : () = c();
diff --git a/tests/ui/closures/print/closure-print-generic-verbose-2.stderr b/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
index 88f4dc9b92a..a8d2b07a00d 100644
--- a/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
+++ b/tests/ui/closures/print/closure-print-generic-verbose-2.stderr
@@ -9,7 +9,7 @@ LL |         let c1 : () = c;
    |                  expected due to this
    |
    = note: expected unit type `()`
-                found closure `{f<T>::{closure#0} closure_kind_ty=?8t closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=?7t}`
+                found closure `{f<T>::{closure#0} closure_kind_ty=?7t closure_sig_as_fn_ptr_ty=extern "rust-call" fn(()) upvar_tys=?6t}`
 help: use parentheses to call this closure
    |
 LL |         let c1 : () = c();
diff --git a/tests/ui/const-generics/const-arg-in-const-arg.min.stderr b/tests/ui/const-generics/const-arg-in-const-arg.min.stderr
index 06a6a5f59d6..16512cb69e2 100644
--- a/tests/ui/const-generics/const-arg-in-const-arg.min.stderr
+++ b/tests/ui/const-generics/const-arg-in-const-arg.min.stderr
@@ -240,41 +240,6 @@ note: the late bound lifetime parameter is introduced here
 LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
    |              ^^
 
-error[E0747]: unresolved item provided when a constant was expected
-  --> $DIR/const-arg-in-const-arg.rs:36:24
-   |
-LL |     let _: Foo<{ bar::<N>() }>;
-   |                        ^
-   |
-help: if this generic argument was intended as a const parameter, surround it with braces
-   |
-LL |     let _: Foo<{ bar::<{ N }>() }>;
-   |                        +   +
-
-error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
-  --> $DIR/const-arg-in-const-arg.rs:38:24
-   |
-LL |     let _: Foo<{ faz::<'a>(&()) }>;
-   |                        ^^
-   |
-note: the late bound lifetime parameter is introduced here
-  --> $DIR/const-arg-in-const-arg.rs:10:14
-   |
-LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
-   |              ^^
-
-error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
-  --> $DIR/const-arg-in-const-arg.rs:41:24
-   |
-LL |     let _: Foo<{ faz::<'b>(&()) }>;
-   |                        ^^
-   |
-note: the late bound lifetime parameter is introduced here
-  --> $DIR/const-arg-in-const-arg.rs:10:14
-   |
-LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
-   |              ^^
-
 error: constant expression depends on a generic parameter
   --> $DIR/const-arg-in-const-arg.rs:25:17
    |
@@ -327,6 +292,41 @@ LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
    |              ^^
 
 error[E0747]: unresolved item provided when a constant was expected
+  --> $DIR/const-arg-in-const-arg.rs:36:24
+   |
+LL |     let _: Foo<{ bar::<N>() }>;
+   |                        ^
+   |
+help: if this generic argument was intended as a const parameter, surround it with braces
+   |
+LL |     let _: Foo<{ bar::<{ N }>() }>;
+   |                        +   +
+
+error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
+  --> $DIR/const-arg-in-const-arg.rs:38:24
+   |
+LL |     let _: Foo<{ faz::<'a>(&()) }>;
+   |                        ^^
+   |
+note: the late bound lifetime parameter is introduced here
+  --> $DIR/const-arg-in-const-arg.rs:10:14
+   |
+LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
+   |              ^^
+
+error[E0794]: cannot specify lifetime arguments explicitly if late bound lifetime parameters are present
+  --> $DIR/const-arg-in-const-arg.rs:41:24
+   |
+LL |     let _: Foo<{ faz::<'b>(&()) }>;
+   |                        ^^
+   |
+note: the late bound lifetime parameter is introduced here
+  --> $DIR/const-arg-in-const-arg.rs:10:14
+   |
+LL | const fn faz<'a>(_: &'a ()) -> usize { 13 }
+   |              ^^
+
+error[E0747]: unresolved item provided when a constant was expected
   --> $DIR/const-arg-in-const-arg.rs:45:27
    |
 LL |     let _ = Foo::<{ bar::<N>() }>;
diff --git a/tests/ui/const-generics/generic_const_exprs/dependence_lint.gce.stderr b/tests/ui/const-generics/generic_const_exprs/dependence_lint.gce.stderr
index 7e318f8786f..f6119c17bf4 100644
--- a/tests/ui/const-generics/generic_const_exprs/dependence_lint.gce.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/dependence_lint.gce.stderr
@@ -1,27 +1,27 @@
-error: overly complex generic constant
-  --> $DIR/dependence_lint.rs:21:17
-   |
-LL |     let _: [u8; if true { size_of::<T>() } else { 3 }]; // error on stable, error with gce
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
-   |
-   = help: consider moving this anonymous constant into a `const` function
-
 error: unconstrained generic constant
-  --> $DIR/dependence_lint.rs:14:12
+  --> $DIR/dependence_lint.rs:10:9
    |
-LL |     let _: [u8; size_of::<*mut T>()]; // error on stable, error with gce
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     [0; size_of::<*mut T>()]; // lint on stable, error with `generic_const_exprs`
+   |         ^^^^^^^^^^^^^^^^^^^
    |
 help: try adding a `where` bound
    |
 LL | fn foo<T>() where [(); size_of::<*mut T>()]: {
    |             ++++++++++++++++++++++++++++++++
 
+error: overly complex generic constant
+  --> $DIR/dependence_lint.rs:17:9
+   |
+LL |     [0; if false { size_of::<T>() } else { 3 }]; // lint on stable, error with gce
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
+   |
+   = help: consider moving this anonymous constant into a `const` function
+
 error: unconstrained generic constant
-  --> $DIR/dependence_lint.rs:10:9
+  --> $DIR/dependence_lint.rs:14:12
    |
-LL |     [0; size_of::<*mut T>()]; // lint on stable, error with `generic_const_exprs`
-   |         ^^^^^^^^^^^^^^^^^^^
+LL |     let _: [u8; size_of::<*mut T>()]; // error on stable, error with gce
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: try adding a `where` bound
    |
@@ -29,10 +29,10 @@ LL | fn foo<T>() where [(); size_of::<*mut T>()]: {
    |             ++++++++++++++++++++++++++++++++
 
 error: overly complex generic constant
-  --> $DIR/dependence_lint.rs:17:9
+  --> $DIR/dependence_lint.rs:21:17
    |
-LL |     [0; if false { size_of::<T>() } else { 3 }]; // lint on stable, error with gce
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
+LL |     let _: [u8; if true { size_of::<T>() } else { 3 }]; // error on stable, error with gce
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ control flow is not supported in generic constants
    |
    = help: consider moving this anonymous constant into a `const` function
 
diff --git a/tests/ui/const-generics/invalid-enum.stderr b/tests/ui/const-generics/invalid-enum.stderr
index 7e8a632b34f..f588ff0bc8e 100644
--- a/tests/ui/const-generics/invalid-enum.stderr
+++ b/tests/ui/const-generics/invalid-enum.stderr
@@ -26,28 +26,6 @@ LL |   let _: Example<CompileFlag::A, _> = Example { x: 0 };
    |                  help: try using the variant's enum: `CompileFlag`
 
 error[E0747]: unresolved item provided when a constant was expected
-  --> $DIR/invalid-enum.rs:31:18
-   |
-LL |   let _: Example<CompileFlag::A, _> = Example { x: 0 };
-   |                  ^^^^^^^^^^^^^^
-   |
-help: if this generic argument was intended as a const parameter, surround it with braces
-   |
-LL |   let _: Example<{ CompileFlag::A }, _> = Example { x: 0 };
-   |                  +                +
-
-error[E0747]: type provided when a constant was expected
-  --> $DIR/invalid-enum.rs:35:18
-   |
-LL |   let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
-   |                  ^^^^^^^^^^^^^^^^^^^
-   |
-help: if this generic argument was intended as a const parameter, surround it with braces
-   |
-LL |   let _: Example<{ Example::ASSOC_FLAG }, _> = Example { x: 0 };
-   |                  +                     +
-
-error[E0747]: unresolved item provided when a constant was expected
   --> $DIR/invalid-enum.rs:23:12
    |
 LL |   test_1::<CompileFlag::A>();
@@ -69,6 +47,28 @@ help: if this generic argument was intended as a const parameter, surround it wi
 LL |   test_2::<_, { CompileFlag::A }>(0);
    |               +                +
 
+error[E0747]: unresolved item provided when a constant was expected
+  --> $DIR/invalid-enum.rs:31:18
+   |
+LL |   let _: Example<CompileFlag::A, _> = Example { x: 0 };
+   |                  ^^^^^^^^^^^^^^
+   |
+help: if this generic argument was intended as a const parameter, surround it with braces
+   |
+LL |   let _: Example<{ CompileFlag::A }, _> = Example { x: 0 };
+   |                  +                +
+
+error[E0747]: type provided when a constant was expected
+  --> $DIR/invalid-enum.rs:35:18
+   |
+LL |   let _: Example<Example::ASSOC_FLAG, _> = Example { x: 0 };
+   |                  ^^^^^^^^^^^^^^^^^^^
+   |
+help: if this generic argument was intended as a const parameter, surround it with braces
+   |
+LL |   let _: Example<{ Example::ASSOC_FLAG }, _> = Example { x: 0 };
+   |                  +                     +
+
 error: aborting due to 7 previous errors
 
 Some errors have detailed explanations: E0573, E0747.
diff --git a/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
index bb3f7899bf1..c1e93ccb83c 100644
--- a/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
+++ b/tests/ui/dyn-compatibility/mention-correct-dyn-incompatible-trait.stderr
@@ -1,8 +1,8 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:15
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:30
    |
 LL |     let test: &mut dyn Bar = &mut thing;
-   |               ^^^^^^^^^^^^ `Bar` is not dyn compatible
+   |                              ^^^^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
@@ -15,12 +15,13 @@ LL | trait Bar: Foo { }
    |       --- this trait is not dyn compatible...
    = help: consider moving `foo` to another trait
    = help: only type `Thing` implements `Bar`; consider using it directly instead.
+   = note: required for the cast from `&mut Thing` to `&mut dyn Bar`
 
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:30
+  --> $DIR/mention-correct-dyn-incompatible-trait.rs:19:15
    |
 LL |     let test: &mut dyn Bar = &mut thing;
-   |                              ^^^^^^^^^^ `Bar` is not dyn compatible
+   |               ^^^^^^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
@@ -33,7 +34,6 @@ LL | trait Bar: Foo { }
    |       --- this trait is not dyn compatible...
    = help: consider moving `foo` to another trait
    = help: only type `Thing` implements `Bar`; consider using it directly instead.
-   = note: required for the cast from `&mut Thing` to `&mut dyn Bar`
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/issues/issue-18959.rs b/tests/ui/issues/issue-18959.rs
index f4cab630f2e..6aeb34879ea 100644
--- a/tests/ui/issues/issue-18959.rs
+++ b/tests/ui/issues/issue-18959.rs
@@ -20,5 +20,4 @@ fn main() {
     //~^ ERROR E0038
     //~| ERROR E0038
     foo(test);
-    //~^ ERROR E0038
 }
diff --git a/tests/ui/issues/issue-18959.stderr b/tests/ui/issues/issue-18959.stderr
index c37c4177bfc..1e050b115e5 100644
--- a/tests/ui/issues/issue-18959.stderr
+++ b/tests/ui/issues/issue-18959.stderr
@@ -31,22 +31,6 @@ LL | pub trait Bar: Foo { }
    = help: consider moving `foo` to another trait
 
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/issue-18959.rs:19:15
-   |
-LL |     let test: &dyn Bar = &mut thing;
-   |               ^^^^^^^^ `Bar` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/issue-18959.rs:1:20
-   |
-LL | pub trait Foo { fn foo<T>(&self, ext_thing: &T); }
-   |                    ^^^ ...because method `foo` has generic type parameters
-LL | pub trait Bar: Foo { }
-   |           --- this trait is not dyn compatible...
-   = help: consider moving `foo` to another trait
-
-error[E0038]: the trait `Bar` is not dyn compatible
   --> $DIR/issue-18959.rs:19:26
    |
 LL |     let test: &dyn Bar = &mut thing;
@@ -64,10 +48,10 @@ LL | pub trait Bar: Foo { }
    = note: required for the cast from `&mut Thing` to `&dyn Bar`
 
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/issue-18959.rs:22:9
+  --> $DIR/issue-18959.rs:19:15
    |
-LL |     foo(test);
-   |         ^^^^ `Bar` is not dyn compatible
+LL |     let test: &dyn Bar = &mut thing;
+   |               ^^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
@@ -79,6 +63,6 @@ LL | pub trait Bar: Foo { }
    |           --- this trait is not dyn compatible...
    = help: consider moving `foo` to another trait
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/lint/bare-trait-objects-path.stderr b/tests/ui/lint/bare-trait-objects-path.stderr
index d2d139dd025..fbb647c37c5 100644
--- a/tests/ui/lint/bare-trait-objects-path.stderr
+++ b/tests/ui/lint/bare-trait-objects-path.stderr
@@ -1,24 +1,4 @@
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/bare-trait-objects-path.rs:23:12
-   |
-LL |     let _: Dyn::Ty;
-   |            ^^^
-   |
-   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
-   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
-   = note: `#[warn(bare_trait_objects)]` on by default
-help: if this is a dyn-compatible trait, use `dyn`
-   |
-LL |     let _: <dyn Dyn>::Ty;
-   |            ++++    +
-
-error[E0223]: ambiguous associated type
-  --> $DIR/bare-trait-objects-path.rs:23:12
-   |
-LL |     let _: Dyn::Ty;
-   |            ^^^^^^^ help: use fully-qualified syntax: `<dyn Dyn as Assoc>::Ty`
-
-warning: trait objects without an explicit `dyn` are deprecated
   --> $DIR/bare-trait-objects-path.rs:14:5
    |
 LL |     Dyn::func();
@@ -26,6 +6,7 @@ LL |     Dyn::func();
    |
    = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+   = note: `#[warn(bare_trait_objects)]` on by default
 help: if this is a dyn-compatible trait, use `dyn`
    |
 LL |     <dyn Dyn>::func();
@@ -57,6 +38,25 @@ help: if this is a dyn-compatible trait, use `dyn`
 LL |     <dyn Dyn>::CONST;
    |     ++++    +
 
+warning: trait objects without an explicit `dyn` are deprecated
+  --> $DIR/bare-trait-objects-path.rs:23:12
+   |
+LL |     let _: Dyn::Ty;
+   |            ^^^
+   |
+   = warning: this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2021/warnings-promoted-to-error.html>
+help: if this is a dyn-compatible trait, use `dyn`
+   |
+LL |     let _: <dyn Dyn>::Ty;
+   |            ++++    +
+
+error[E0223]: ambiguous associated type
+  --> $DIR/bare-trait-objects-path.rs:23:12
+   |
+LL |     let _: Dyn::Ty;
+   |            ^^^^^^^ help: use fully-qualified syntax: `<dyn Dyn as Assoc>::Ty`
+
 error: aborting due to 1 previous error; 4 warnings emitted
 
 For more information about this error, try `rustc --explain E0223`.
diff --git a/tests/ui/methods/disambiguate-multiple-blanket-impl.stderr b/tests/ui/methods/disambiguate-multiple-blanket-impl.stderr
index 1b81dc5aafb..ee698ed0e75 100644
--- a/tests/ui/methods/disambiguate-multiple-blanket-impl.stderr
+++ b/tests/ui/methods/disambiguate-multiple-blanket-impl.stderr
@@ -1,18 +1,3 @@
-error[E0223]: ambiguous associated type
-  --> $DIR/disambiguate-multiple-blanket-impl.rs:36:12
-   |
-LL |     let _: S::Type;
-   |            ^^^^^^^
-   |
-help: use fully-qualified syntax
-   |
-LL -     let _: S::Type;
-LL +     let _: <S as A>::Type;
-   |
-LL -     let _: S::Type;
-LL +     let _: <S as B>::Type;
-   |
-
 error[E0034]: multiple applicable items in scope
   --> $DIR/disambiguate-multiple-blanket-impl.rs:30:8
    |
@@ -63,6 +48,21 @@ LL -     S::CONST;
 LL +     <S as B>::CONST;
    |
 
+error[E0223]: ambiguous associated type
+  --> $DIR/disambiguate-multiple-blanket-impl.rs:36:12
+   |
+LL |     let _: S::Type;
+   |            ^^^^^^^
+   |
+help: use fully-qualified syntax
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as A>::Type;
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as B>::Type;
+   |
+
 error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0034, E0223.
diff --git a/tests/ui/methods/disambiguate-multiple-impl.stderr b/tests/ui/methods/disambiguate-multiple-impl.stderr
index 2563c2327b7..319d5886f8e 100644
--- a/tests/ui/methods/disambiguate-multiple-impl.stderr
+++ b/tests/ui/methods/disambiguate-multiple-impl.stderr
@@ -1,18 +1,3 @@
-error[E0223]: ambiguous associated type
-  --> $DIR/disambiguate-multiple-impl.rs:32:12
-   |
-LL |     let _: S::Type = ();
-   |            ^^^^^^^
-   |
-help: use fully-qualified syntax
-   |
-LL -     let _: S::Type = ();
-LL +     let _: <S as A>::Type = ();
-   |
-LL -     let _: S::Type = ();
-LL +     let _: <S as B>::Type = ();
-   |
-
 error[E0034]: multiple applicable items in scope
   --> $DIR/disambiguate-multiple-impl.rs:29:8
    |
@@ -38,6 +23,21 @@ LL -     S::foo(&s);
 LL +     B::foo(&s);
    |
 
+error[E0223]: ambiguous associated type
+  --> $DIR/disambiguate-multiple-impl.rs:32:12
+   |
+LL |     let _: S::Type = ();
+   |            ^^^^^^^
+   |
+help: use fully-qualified syntax
+   |
+LL -     let _: S::Type = ();
+LL +     let _: <S as A>::Type = ();
+   |
+LL -     let _: S::Type = ();
+LL +     let _: <S as B>::Type = ();
+   |
+
 error[E0034]: multiple applicable items in scope
   --> $DIR/disambiguate-multiple-impl.rs:34:16
    |
diff --git a/tests/ui/methods/disambiguate-multiple-trait-2.stderr b/tests/ui/methods/disambiguate-multiple-trait-2.stderr
index 08e264c20c8..f9119e60750 100644
--- a/tests/ui/methods/disambiguate-multiple-trait-2.stderr
+++ b/tests/ui/methods/disambiguate-multiple-trait-2.stderr
@@ -1,26 +1,3 @@
-error[E0221]: ambiguous associated type `Type` in bounds of `T`
-  --> $DIR/disambiguate-multiple-trait-2.rs:23:12
-   |
-LL |     type Type;
-   |     --------- ambiguous `Type` from `A`
-...
-LL |     type Type;
-   |     --------- ambiguous `Type` from `B`
-...
-LL |     let _: T::Type;
-   |            ^^^^^^^ ambiguous associated type `Type`
-   |
-help: use fully-qualified syntax to disambiguate
-   |
-LL -     let _: T::Type;
-LL +     let _: <T as A>::Type;
-   |
-help: use fully-qualified syntax to disambiguate
-   |
-LL -     let _: T::Type;
-LL +     let _: <T as B>::Type;
-   |
-
 error[E0034]: multiple applicable items in scope
   --> $DIR/disambiguate-multiple-trait-2.rs:16:7
    |
@@ -73,19 +50,27 @@ LL -     let _ = T::CONST;
 LL +     let _ = <T as B>::CONST;
    |
 
-error[E0223]: ambiguous associated type
-  --> $DIR/disambiguate-multiple-trait-2.rs:52:12
+error[E0221]: ambiguous associated type `Type` in bounds of `T`
+  --> $DIR/disambiguate-multiple-trait-2.rs:23:12
    |
-LL |     let _: S::Type;
-   |            ^^^^^^^
+LL |     type Type;
+   |     --------- ambiguous `Type` from `A`
+...
+LL |     type Type;
+   |     --------- ambiguous `Type` from `B`
+...
+LL |     let _: T::Type;
+   |            ^^^^^^^ ambiguous associated type `Type`
    |
-help: use fully-qualified syntax
+help: use fully-qualified syntax to disambiguate
    |
-LL -     let _: S::Type;
-LL +     let _: <S as A>::Type;
+LL -     let _: T::Type;
+LL +     let _: <T as A>::Type;
    |
-LL -     let _: S::Type;
-LL +     let _: <S as B>::Type;
+help: use fully-qualified syntax to disambiguate
+   |
+LL -     let _: T::Type;
+LL +     let _: <T as B>::Type;
    |
 
 error[E0034]: multiple applicable items in scope
@@ -138,6 +123,21 @@ LL -     let _ = S::CONST;
 LL +     let _ = <S as B>::CONST;
    |
 
+error[E0223]: ambiguous associated type
+  --> $DIR/disambiguate-multiple-trait-2.rs:52:12
+   |
+LL |     let _: S::Type;
+   |            ^^^^^^^
+   |
+help: use fully-qualified syntax
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as A>::Type;
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as B>::Type;
+   |
+
 error: aborting due to 6 previous errors
 
 Some errors have detailed explanations: E0034, E0221, E0223.
diff --git a/tests/ui/methods/disambiguate-multiple-trait.stderr b/tests/ui/methods/disambiguate-multiple-trait.stderr
index a977fe2cd03..f35eec3b048 100644
--- a/tests/ui/methods/disambiguate-multiple-trait.stderr
+++ b/tests/ui/methods/disambiguate-multiple-trait.stderr
@@ -1,18 +1,3 @@
-error[E0223]: ambiguous associated type
-  --> $DIR/disambiguate-multiple-trait.rs:30:12
-   |
-LL |     let _: S::Type;
-   |            ^^^^^^^
-   |
-help: use fully-qualified syntax
-   |
-LL -     let _: S::Type;
-LL +     let _: <S as A>::Type;
-   |
-LL -     let _: S::Type;
-LL +     let _: <S as B>::Type;
-   |
-
 error[E0034]: multiple applicable items in scope
   --> $DIR/disambiguate-multiple-trait.rs:24:8
    |
@@ -63,6 +48,21 @@ LL -     let _ = S::CONST;
 LL +     let _ = <S as B>::CONST;
    |
 
+error[E0223]: ambiguous associated type
+  --> $DIR/disambiguate-multiple-trait.rs:30:12
+   |
+LL |     let _: S::Type;
+   |            ^^^^^^^
+   |
+help: use fully-qualified syntax
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as A>::Type;
+   |
+LL -     let _: S::Type;
+LL +     let _: <S as B>::Type;
+   |
+
 error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0034, E0223.
diff --git a/tests/ui/stability-attribute/generics-default-stability.stderr b/tests/ui/stability-attribute/generics-default-stability.stderr
index f4f51a14248..53ef3e170cc 100644
--- a/tests/ui/stability-attribute/generics-default-stability.stderr
+++ b/tests/ui/stability-attribute/generics-default-stability.stderr
@@ -270,6 +270,18 @@ LL |     let _: Struct3<usize, usize> = Struct3 { field1: 0, field2: 0 };
    = help: add `#![feature(unstable_default)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
+warning: use of deprecated field `unstable_generic_param::Struct4::field`: test
+  --> $DIR/generics-default-stability.rs:71:39
+   |
+LL |     let _: Struct4<isize> = Struct4 { field: 1 };
+   |                                       ^^^^^^^^
+
+warning: use of deprecated field `unstable_generic_param::Struct4::field`: test
+  --> $DIR/generics-default-stability.rs:78:39
+   |
+LL |     let _: Struct4<isize> = Struct4 { field: 0 };
+   |                                       ^^^^^^^^
+
 error[E0658]: use of unstable library feature `unstable_default`
   --> $DIR/generics-default-stability.rs:84:20
    |
@@ -279,6 +291,12 @@ LL |     let _: Struct5<isize> = Struct5 { field: 1 };
    = help: add `#![feature(unstable_default)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
+warning: use of deprecated field `unstable_generic_param::Struct5::field`: test
+  --> $DIR/generics-default-stability.rs:84:39
+   |
+LL |     let _: Struct5<isize> = Struct5 { field: 1 };
+   |                                       ^^^^^^^^
+
 error[E0658]: use of unstable library feature `unstable_default`
   --> $DIR/generics-default-stability.rs:90:20
    |
@@ -297,6 +315,12 @@ LL |     let _: Struct5<isize> = Struct5 { field: 0 };
    = help: add `#![feature(unstable_default)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
+warning: use of deprecated field `unstable_generic_param::Struct5::field`: test
+  --> $DIR/generics-default-stability.rs:92:39
+   |
+LL |     let _: Struct5<isize> = Struct5 { field: 0 };
+   |                                       ^^^^^^^^
+
 error[E0658]: use of unstable library feature `unstable_default`
   --> $DIR/generics-default-stability.rs:100:19
    |
@@ -468,30 +492,6 @@ LL |     let _: Box1<isize, System> = Box1::new(1);
    = help: add `#![feature(box_alloc_param)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-warning: use of deprecated field `unstable_generic_param::Struct4::field`: test
-  --> $DIR/generics-default-stability.rs:71:39
-   |
-LL |     let _: Struct4<isize> = Struct4 { field: 1 };
-   |                                       ^^^^^^^^
-
-warning: use of deprecated field `unstable_generic_param::Struct4::field`: test
-  --> $DIR/generics-default-stability.rs:78:39
-   |
-LL |     let _: Struct4<isize> = Struct4 { field: 0 };
-   |                                       ^^^^^^^^
-
-warning: use of deprecated field `unstable_generic_param::Struct5::field`: test
-  --> $DIR/generics-default-stability.rs:84:39
-   |
-LL |     let _: Struct5<isize> = Struct5 { field: 1 };
-   |                                       ^^^^^^^^
-
-warning: use of deprecated field `unstable_generic_param::Struct5::field`: test
-  --> $DIR/generics-default-stability.rs:92:39
-   |
-LL |     let _: Struct5<isize> = Struct5 { field: 0 };
-   |                                       ^^^^^^^^
-
 error: aborting due to 28 previous errors; 40 warnings emitted
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/stability-attribute/suggest-vec-allocator-api.stderr b/tests/ui/stability-attribute/suggest-vec-allocator-api.stderr
index 6662ceda90b..78b7d07b60c 100644
--- a/tests/ui/stability-attribute/suggest-vec-allocator-api.stderr
+++ b/tests/ui/stability-attribute/suggest-vec-allocator-api.stderr
@@ -27,22 +27,22 @@ LL ~         _)> = vec![];
    |
 
 error[E0658]: use of unstable library feature `allocator_api`
-  --> $DIR/suggest-vec-allocator-api.rs:8:26
+  --> $DIR/suggest-vec-allocator-api.rs:7:24
    |
-LL |     let _boxed: Box<u32, _> = Box::new(10);
-   |                          ^
+LL |     let _ = Vec::<u16, _>::new();
+   |                   -----^
+   |                   |
+   |                   help: consider wrapping the inner types in tuple: `(u16, _)`
    |
    = note: see issue #32838 <https://github.com/rust-lang/rust/issues/32838> for more information
    = help: add `#![feature(allocator_api)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: use of unstable library feature `allocator_api`
-  --> $DIR/suggest-vec-allocator-api.rs:7:24
+  --> $DIR/suggest-vec-allocator-api.rs:8:26
    |
-LL |     let _ = Vec::<u16, _>::new();
-   |                   -----^
-   |                   |
-   |                   help: consider wrapping the inner types in tuple: `(u16, _)`
+LL |     let _boxed: Box<u32, _> = Box::new(10);
+   |                          ^
    |
    = note: see issue #32838 <https://github.com/rust-lang/rust/issues/32838> for more information
    = help: add `#![feature(allocator_api)]` to the crate attributes to enable
diff --git a/tests/ui/traits/bound/on-structs-and-enums-locals.stderr b/tests/ui/traits/bound/on-structs-and-enums-locals.stderr
index 01cf76c62d5..88077f4e4d7 100644
--- a/tests/ui/traits/bound/on-structs-and-enums-locals.stderr
+++ b/tests/ui/traits/bound/on-structs-and-enums-locals.stderr
@@ -1,8 +1,8 @@
-error[E0277]: the trait bound `usize: Trait` is not satisfied
-  --> $DIR/on-structs-and-enums-locals.rs:15:14
+error[E0277]: the trait bound `{integer}: Trait` is not satisfied
+  --> $DIR/on-structs-and-enums-locals.rs:11:12
    |
-LL |     let baz: Foo<usize> = loop { };
-   |              ^^^^^^^^^^ the trait `Trait` is not implemented for `usize`
+LL |         x: 3
+   |            ^ the trait `Trait` is not implemented for `{integer}`
    |
 help: this trait has no implementations, consider adding one
   --> $DIR/on-structs-and-enums-locals.rs:1:1
@@ -15,11 +15,11 @@ note: required by a bound in `Foo`
 LL | struct Foo<T:Trait> {
    |              ^^^^^ required by this bound in `Foo`
 
-error[E0277]: the trait bound `{integer}: Trait` is not satisfied
-  --> $DIR/on-structs-and-enums-locals.rs:11:12
+error[E0277]: the trait bound `usize: Trait` is not satisfied
+  --> $DIR/on-structs-and-enums-locals.rs:15:14
    |
-LL |         x: 3
-   |            ^ the trait `Trait` is not implemented for `{integer}`
+LL |     let baz: Foo<usize> = loop { };
+   |              ^^^^^^^^^^ the trait `Trait` is not implemented for `usize`
    |
 help: this trait has no implementations, consider adding one
   --> $DIR/on-structs-and-enums-locals.rs:1:1
diff --git a/tests/ui/traits/bound/on-structs-and-enums-xc1.stderr b/tests/ui/traits/bound/on-structs-and-enums-xc1.stderr
index 3fb5decb723..1f46415e243 100644
--- a/tests/ui/traits/bound/on-structs-and-enums-xc1.stderr
+++ b/tests/ui/traits/bound/on-structs-and-enums-xc1.stderr
@@ -1,15 +1,3 @@
-error[E0277]: the trait bound `f64: Trait` is not satisfied
-  --> $DIR/on-structs-and-enums-xc1.rs:12:14
-   |
-LL |     let bar: Bar<f64> = return;
-   |              ^^^^^^^^ the trait `Trait` is not implemented for `f64`
-   |
-note: required by a bound in `Bar`
-  --> $DIR/auxiliary/on_structs_and_enums_xc.rs:9:16
-   |
-LL | pub enum Bar<T:Trait> {
-   |                ^^^^^ required by this bound in `Bar`
-
 error[E0277]: the trait bound `{integer}: Trait` is not satisfied
   --> $DIR/on-structs-and-enums-xc1.rs:9:12
    |
@@ -22,6 +10,18 @@ note: required by a bound in `Foo`
 LL | pub struct Foo<T:Trait> {
    |                  ^^^^^ required by this bound in `Foo`
 
+error[E0277]: the trait bound `f64: Trait` is not satisfied
+  --> $DIR/on-structs-and-enums-xc1.rs:12:14
+   |
+LL |     let bar: Bar<f64> = return;
+   |              ^^^^^^^^ the trait `Trait` is not implemented for `f64`
+   |
+note: required by a bound in `Bar`
+  --> $DIR/auxiliary/on_structs_and_enums_xc.rs:9:16
+   |
+LL | pub enum Bar<T:Trait> {
+   |                ^^^^^ required by this bound in `Bar`
+
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0277`.