Auto merge of #127117 - Urgau:non_local_def-syntactic, r=BoxyUwU

Rework `non_local_definitions` lint to only use a syntactic heuristic

This PR reworks the `non_local_definitions` lint to only use a syntactic heuristic, i.e. not use a type-system logic for whenever an `impl` is local or not.

Instead the new logic wanted by T-lang in https://github.com/rust-lang/rust/issues/126768#issuecomment-2192634762, which is to consider every paths in `Self` and `Trait` and to no longer use the type-system inference trick.

`@rustbot` labels +L-non_local_definitions
Fixes #126768

compiler/rustc_lint/messages.ftl

@@ -592,10 +592,7 @@ lint_non_local_definitions_cargo_update = the {$macro_kind} `{$macro_name}` may
 lint_non_local_definitions_deprecation = this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 lint_non_local_definitions_impl = non-local `impl` definition, `impl` blocks should be written at the same level as their item
-    .remove_help = remove `{$may_remove_part}` to make the `impl` local
+    .non_local = an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-    .without_trait = methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
-    .with_trait = an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-    .bounds = `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
     .doctest = make this doc-test a standalone test with its own `fn main() {"{"} ... {"}"}`
     .exception = items in an anonymous const item (`const _: () = {"{"} ... {"}"}`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
     .const_anon = use a const-anon item to suppress this lint
@@ -617,12 +614,6 @@ lint_non_local_definitions_macro_rules = non-local `macro_rules!` definition, `#
         remove the `#[macro_export]` or make this doc-test a standalone test with its own `fn main() {"{"} ... {"}"}`
     .non_local = a `macro_rules!` definition is non-local if it is nested inside an item and has a `#[macro_export]` attribute
 
-lint_non_local_definitions_may_move = may need to be moved as well
-
-lint_non_local_definitions_of_trait_not_local = `{$of_trait_str}` is not local
-
-lint_non_local_definitions_self_ty_not_local = `{$self_ty_str}` is not local
-
 lint_non_snake_case = {$sort} `{$name}` should have a snake case name
     .rename_or_convert_suggestion = rename the identifier or convert it to a snake case raw identifier
     .cannot_convert_note = `{$sc}` cannot be used as a raw identifier

compiler/rustc_lint/src/lints.rs

@@ -1375,12 +1375,7 @@ pub(crate) enum NonLocalDefinitionsDiag {
         body_name: String,
         cargo_update: Option<NonLocalDefinitionsCargoUpdateNote>,
         const_anon: Option<Option<Span>>,
-        move_to: Option<(Span, Vec<Span>)>,
         doctest: bool,
-        may_remove: Option<(Span, String)>,
-        has_trait: bool,
-        self_ty_str: String,
-        of_trait_str: Option<String>,
         macro_to_change: Option<(String, &'static str)>,
     },
     MacroRules {
@@ -1401,22 +1396,13 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
                 body_name,
                 cargo_update,
                 const_anon,
-                move_to,
                 doctest,
-                may_remove,
-                has_trait,
-                self_ty_str,
-                of_trait_str,
                 macro_to_change,
             } => {
                 diag.primary_message(fluent::lint_non_local_definitions_impl);
                 diag.arg("depth", depth);
                 diag.arg("body_kind_descr", body_kind_descr);
                 diag.arg("body_name", body_name);
-                diag.arg("self_ty_str", self_ty_str);
-                if let Some(of_trait_str) = of_trait_str {
-                    diag.arg("of_trait_str", of_trait_str);
-                }
 
                 if let Some((macro_to_change, macro_kind)) = macro_to_change {
                     diag.arg("macro_to_change", macro_to_change);
@@ -1427,34 +1413,12 @@ impl<'a> LintDiagnostic<'a, ()> for NonLocalDefinitionsDiag {
                     diag.subdiagnostic(cargo_update);
                 }
 
-                if has_trait {
+                diag.note(fluent::lint_non_local);
-                    diag.note(fluent::lint_bounds);
-                    diag.note(fluent::lint_with_trait);
-                } else {
-                    diag.note(fluent::lint_without_trait);
-                }
 
-                if let Some((move_help, may_move)) = move_to {
-                    let mut ms = MultiSpan::from_span(move_help);
-                    for sp in may_move {
-                        ms.push_span_label(sp, fluent::lint_non_local_definitions_may_move);
-                    }
-                    diag.span_help(ms, fluent::lint_non_local_definitions_impl_move_help);
-                }
                 if doctest {
                     diag.help(fluent::lint_doctest);
                 }
 
-                if let Some((span, part)) = may_remove {
-                    diag.arg("may_remove_part", part);
-                    diag.span_suggestion(
-                        span,
-                        fluent::lint_remove_help,
-                        "",
-                        Applicability::MaybeIncorrect,
-                    );
-                }
-
                 if let Some(const_anon) = const_anon {
                     diag.note(fluent::lint_exception);
                     if let Some(const_anon) = const_anon {

compiler/rustc_lint/src/non_local_def.rs

@@ -1,20 +1,12 @@
 use rustc_errors::MultiSpan;
-use rustc_hir::def::DefKind;
+use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{self, Visitor};
-use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, QPath, TyKind};
+use rustc_hir::{Body, HirId, Item, ItemKind, Node, Path, TyKind};
-use rustc_infer::infer::InferCtxt;
+use rustc_middle::ty::TyCtxt;
-use rustc_infer::traits::{Obligation, ObligationCause};
-use rustc_middle::ty::{
-    self, Binder, EarlyBinder, TraitRef, Ty, TyCtxt, TypeFoldable, TypeFolder, TypeSuperFoldable,
-};
 use rustc_session::{declare_lint, impl_lint_pass};
 use rustc_span::def_id::{DefId, LOCAL_CRATE};
 use rustc_span::symbol::kw;
-use rustc_span::{ExpnKind, MacroKind, Span, Symbol, sym};
+use rustc_span::{ExpnKind, MacroKind, Span, sym};
-use rustc_trait_selection::error_reporting::traits::ambiguity::{
-    CandidateSource, compute_applicable_impls_for_diagnostics,
-};
-use rustc_trait_selection::infer::TyCtxtInferExt;
 
 use crate::lints::{NonLocalDefinitionsCargoUpdateNote, NonLocalDefinitionsDiag};
 use crate::{LateContext, LateLintPass, LintContext, fluent_generated as fluent};
@@ -49,7 +41,7 @@ declare_lint! {
     /// All nested bodies (functions, enum discriminant, array length, consts) (expect for
     /// `const _: Ty = { ... }` in top-level module, which is still undecided) are checked.
     pub NON_LOCAL_DEFINITIONS,
-    Allow,
+    Warn,
     "checks for non-local definitions",
     report_in_external_macro
 }
@@ -142,42 +134,28 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                     None
                 };
 
-                // Part 1: Is the Self type local?
+                // 1. We collect all the `hir::Path` from the `Self` type and `Trait` ref
-                let self_ty_has_local_parent =
+                // of the `impl` definition
-                    ty_has_local_parent(&impl_.self_ty.kind, cx, parent, parent_parent);
+                let mut collector = PathCollector { paths: Vec::new() };
-
+                collector.visit_ty(&impl_.self_ty);
-                if self_ty_has_local_parent {
+                if let Some(of_trait) = &impl_.of_trait {
-                    return;
+                    collector.visit_trait_ref(of_trait);
                 }
 
-                // Part 2: Is the Trait local?
+                // 1.5. Remove any path that doesn't resolve to a `DefId` or if it resolve to a
-                let of_trait_has_local_parent = impl_
+                // type-param (e.g. `T`).
-                    .of_trait
+                collector.paths.retain(
-                    .map(|of_trait| path_has_local_parent(of_trait.path, cx, parent, parent_parent))
+                    |p| matches!(p.res, Res::Def(def_kind, _) if def_kind != DefKind::TyParam),
-                    .unwrap_or(false);
+                );
 
-                if of_trait_has_local_parent {
+                // 2. We check if any of path reference a "local" parent and if that the case
-                    return;
+                // we bail out as asked by T-lang, even though this isn't correct from a
-                }
+                // type-system point of view, as inference exists and could still leak the impl.
-
+                if collector
-                // Part 3: Is the impl definition leaking outside it's defining scope?
+                    .paths
-                //
+                    .iter()
-                // We always consider inherent impls to be leaking.
+                    .any(|path| path_has_local_parent(path, cx, parent, parent_parent))
-                let impl_has_enough_non_local_candidates = cx
+                {
-                    .tcx
-                    .impl_trait_ref(def_id)
-                    .map(|binder| {
-                        impl_trait_ref_has_enough_non_local_candidates(
-                            cx.tcx,
-                            item.span,
-                            def_id,
-                            binder,
-                            |did| did_has_local_parent(did, cx.tcx, parent, parent_parent),
-                        )
-                    })
-                    .unwrap_or(false);
-
-                if impl_has_enough_non_local_candidates {
                     return;
                 }
 
@@ -199,76 +177,28 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                 let const_anon = matches!(parent_def_kind, DefKind::Const | DefKind::Static { .. })
                     .then_some(span_for_const_anon_suggestion);
 
-                let may_remove = match &impl_.self_ty.kind {
-                    TyKind::Ptr(mut_ty) | TyKind::Ref(_, mut_ty)
-                        if ty_has_local_parent(&mut_ty.ty.kind, cx, parent, parent_parent) =>
-                    {
-                        let type_ =
-                            if matches!(impl_.self_ty.kind, TyKind::Ptr(_)) { "*" } else { "&" };
-                        let part = format!("{}{}", type_, mut_ty.mutbl.prefix_str());
-                        Some((impl_.self_ty.span.shrink_to_lo().until(mut_ty.ty.span), part))
-                    }
-                    _ => None,
-                };
-
                 let impl_span = item.span.shrink_to_lo().to(impl_.self_ty.span);
                 let mut ms = MultiSpan::from_span(impl_span);
 
-                let (self_ty_span, self_ty_str) =
+                for path in &collector.paths {
-                    self_ty_kind_for_diagnostic(&impl_.self_ty, cx.tcx);
+                    // FIXME: While a translatable diagnostic message can have an argument
-
+                    // we (currently) have no way to set different args per diag msg with
+                    // `MultiSpan::push_span_label`.
+                    #[allow(rustc::untranslatable_diagnostic)]
                     ms.push_span_label(
-                    self_ty_span,
+                        path_span_without_args(path),
-                    fluent::lint_non_local_definitions_self_ty_not_local,
+                        format!("`{}` is not local", path_name_to_string(path)),
                     );
-                let of_trait_str = if let Some(of_trait) = &impl_.of_trait {
-                    ms.push_span_label(
-                        path_span_without_args(&of_trait.path),
-                        fluent::lint_non_local_definitions_of_trait_not_local,
-                    );
-                    Some(path_name_to_string(&of_trait.path))
-                } else {
-                    None
-                };
-
-                let (doctest, move_to) = if is_at_toplevel_doctest() {
-                    (true, None)
-                } else {
-                    let mut collector = PathCollector { paths: Vec::new() };
-                    collector.visit_ty(&impl_.self_ty);
-                    if let Some(of_trait) = &impl_.of_trait {
-                        collector.visit_trait_ref(of_trait);
                 }
-                    collector.visit_generics(&impl_.generics);
 
-                    let mut may_move: Vec<Span> = collector
+                let doctest = is_at_toplevel_doctest();
-                        .paths
-                        .into_iter()
-                        .filter_map(|path| {
-                            if let Some(did) = path.res.opt_def_id()
-                                && did_has_local_parent(did, cx.tcx, parent, parent_parent)
-                            {
-                                Some(cx.tcx.def_span(did))
-                            } else {
-                                None
-                            }
-                        })
-                        .collect();
-                    may_move.sort();
-                    may_move.dedup();
 
-                    let move_to = if may_move.is_empty() {
+                if !doctest {
                     ms.push_span_label(
                         cx.tcx.def_span(parent),
                         fluent::lint_non_local_definitions_impl_move_help,
                     );
-                        None
+                }
-                    } else {
-                        Some((cx.tcx.def_span(parent), may_move))
-                    };
-
-                    (false, move_to)
-                };
 
                 let macro_to_change =
                     if let ExpnKind::Macro(kind, name) = item.span.ctxt().outer_expn_data().kind {
@@ -285,12 +215,7 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
                         .unwrap_or_else(|| "<unnameable>".to_string()),
                     cargo_update: cargo_update(),
                     const_anon,
-                    self_ty_str,
-                    of_trait_str,
-                    move_to,
                     doctest,
-                    may_remove,
-                    has_trait: impl_.of_trait.is_some(),
                     macro_to_change,
                 })
             }
@@ -316,90 +241,6 @@ impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
     }
 }
 
-// Detecting if the impl definition is leaking outside of its defining scope.
-//
-// Rule: for each impl, instantiate all local types with inference vars and
-// then assemble candidates for that goal, if there are more than 1 (non-private
-// impls), it does not leak.
-//
-// https://github.com/rust-lang/rust/issues/121621#issuecomment-1976826895
-fn impl_trait_ref_has_enough_non_local_candidates<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    infer_span: Span,
-    trait_def_id: DefId,
-    binder: EarlyBinder<'tcx, TraitRef<'tcx>>,
-    mut did_has_local_parent: impl FnMut(DefId) -> bool,
-) -> bool {
-    let infcx = tcx
-        .infer_ctxt()
-        // We use the new trait solver since the obligation we are trying to
-        // prove here may overflow and those are fatal in the old trait solver.
-        // Which is unacceptable for a lint.
-        //
-        // Thanksfully the part we use here are very similar to the
-        // new-trait-solver-as-coherence, which is in stabilization.
-        //
-        // https://github.com/rust-lang/rust/issues/123573
-        .with_next_trait_solver(true)
-        .build();
-
-    let trait_ref = binder.instantiate(tcx, infcx.fresh_args_for_item(infer_span, trait_def_id));
-
-    let trait_ref = trait_ref.fold_with(&mut ReplaceLocalTypesWithInfer {
-        infcx: &infcx,
-        infer_span,
-        did_has_local_parent: &mut did_has_local_parent,
-    });
-
-    let poly_trait_obligation = Obligation::new(
-        tcx,
-        ObligationCause::dummy(),
-        ty::ParamEnv::empty(),
-        Binder::dummy(trait_ref),
-    );
-
-    let ambiguities = compute_applicable_impls_for_diagnostics(&infcx, &poly_trait_obligation);
-
-    let mut it = ambiguities.iter().filter(|ambi| match ambi {
-        CandidateSource::DefId(did) => !did_has_local_parent(*did),
-        CandidateSource::ParamEnv(_) => unreachable!(),
-    });
-
-    let _ = it.next();
-    it.next().is_some()
-}
-
-/// Replace every local type by inference variable.
-///
-/// ```text
-/// <Global<Local> as std::cmp::PartialEq<Global<Local>>>
-/// to
-/// <Global<_> as std::cmp::PartialEq<Global<_>>>
-/// ```
-struct ReplaceLocalTypesWithInfer<'a, 'tcx, F: FnMut(DefId) -> bool> {
-    infcx: &'a InferCtxt<'tcx>,
-    did_has_local_parent: F,
-    infer_span: Span,
-}
-
-impl<'a, 'tcx, F: FnMut(DefId) -> bool> TypeFolder<TyCtxt<'tcx>>
-    for ReplaceLocalTypesWithInfer<'a, 'tcx, F>
-{
-    fn cx(&self) -> TyCtxt<'tcx> {
-        self.infcx.tcx
-    }
-
-    fn fold_ty(&mut self, t: Ty<'tcx>) -> Ty<'tcx> {
-        if let Some(def) = t.ty_adt_def()
-            && (self.did_has_local_parent)(def.did())
-        {
-            self.infcx.next_ty_var(self.infer_span)
-        } else {
-            t.super_fold_with(self)
-        }
-    }
-}
-
 /// Simple hir::Path collector
 struct PathCollector<'tcx> {
     paths: Vec<Path<'tcx>>,
@@ -412,42 +253,6 @@ impl<'tcx> Visitor<'tcx> for PathCollector<'tcx> {
     }
 }
 
-/// Given a `Ty` we check if the (outermost) type is local.
-fn ty_has_local_parent(
-    ty_kind: &TyKind<'_>,
-    cx: &LateContext<'_>,
-    impl_parent: DefId,
-    impl_parent_parent: Option<DefId>,
-) -> bool {
-    match ty_kind {
-        TyKind::Path(QPath::Resolved(_, ty_path)) => {
-            path_has_local_parent(ty_path, cx, impl_parent, impl_parent_parent)
-        }
-        TyKind::TraitObject([principle_poly_trait_ref, ..], _, _) => path_has_local_parent(
-            principle_poly_trait_ref.0.trait_ref.path,
-            cx,
-            impl_parent,
-            impl_parent_parent,
-        ),
-        TyKind::TraitObject([], _, _)
-        | TyKind::InferDelegation(_, _)
-        | TyKind::Slice(_)
-        | TyKind::Array(_, _)
-        | TyKind::Ptr(_)
-        | TyKind::Ref(_, _)
-        | TyKind::BareFn(_)
-        | TyKind::Never
-        | TyKind::Tup(_)
-        | TyKind::Path(_)
-        | TyKind::Pat(..)
-        | TyKind::AnonAdt(_)
-        | TyKind::OpaqueDef(_, _, _)
-        | TyKind::Typeof(_)
-        | TyKind::Infer
-        | TyKind::Err(_) => false,
-    }
-}
-
 /// Given a path and a parent impl def id, this checks if the if parent resolution
 /// def id correspond to the def id of the parent impl definition.
 ///
@@ -503,38 +308,3 @@ fn path_span_without_args(path: &Path<'_>) -> Span {
 fn path_name_to_string(path: &Path<'_>) -> String {
     path.segments.last().unwrap().ident.name.to_ident_string()
 }
-
-/// Compute the `Span` and visual representation for the `Self` we want to point at;
-/// It follows part of the actual logic of non-local, and if possible return the least
-/// amount possible for the span and representation.
-fn self_ty_kind_for_diagnostic(ty: &rustc_hir::Ty<'_>, tcx: TyCtxt<'_>) -> (Span, String) {
-    match ty.kind {
-        TyKind::Path(QPath::Resolved(_, ty_path)) => (
-            path_span_without_args(ty_path),
-            ty_path
-                .res
-                .opt_def_id()
-                .map(|did| tcx.opt_item_name(did))
-                .flatten()
-                .as_ref()
-                .map(|s| Symbol::as_str(s))
-                .unwrap_or("<unnameable>")
-                .to_string(),
-        ),
-        TyKind::TraitObject([principle_poly_trait_ref, ..], _, _) => {
-            let path = &principle_poly_trait_ref.0.trait_ref.path;
-            (
-                path_span_without_args(path),
-                path.res
-                    .opt_def_id()
-                    .map(|did| tcx.opt_item_name(did))
-                    .flatten()
-                    .as_ref()
-                    .map(|s| Symbol::as_str(s))
-                    .unwrap_or("<unnameable>")
-                    .to_string(),
-            )
-        }
-        _ => (ty.span, rustc_hir_pretty::ty_to_string(&tcx, ty)),
-    }
-}

tests/rustdoc-ui/doctest/non-local-defs-impl.rs

@@ -15,7 +15,10 @@
 /// # use pub_trait::Trait;
 ///
 /// struct Local;
+///
+/// fn foo() {
 ///     impl Trait for &Local {}
+/// }
 /// ```
 ///
 /// But this shoudln't produce a warning:

tests/rustdoc-ui/doctest/non-local-defs-impl.stdout

@@ -1,24 +1,23 @@
 
 running 2 tests
 test $DIR/non-local-defs-impl.rs - doctest (line 13) - compile ... FAILED
-test $DIR/non-local-defs-impl.rs - doctest (line 22) - compile ... ok
+test $DIR/non-local-defs-impl.rs - doctest (line 25) - compile ... ok
 
 failures:
 
 ---- $DIR/non-local-defs-impl.rs - doctest (line 13) stdout ----
 error: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/non-local-defs-impl.rs:18:1
+  --> $DIR/non-local-defs-impl.rs:20:5
    |
+LL | fn foo() {
+   | -------- move the `impl` block outside of this function `foo` and up 3 bodies
 LL |     impl Trait for &Local {}
-   | ^^^^^-----^^^^^------
+   |     ^^^^^-----^^^^^^-----
    |          |          |
-   |      |         `&'_ Local` is not local
+   |          |          `Local` is not local
-   |      |         help: remove `&` to make the `impl` local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-   = help: make this doc-test a standalone test with its own `fn main() { ... }`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 note: the lint level is defined here
   --> $DIR/non-local-defs-impl.rs:11:9

tests/rustdoc-ui/doctest/non_local_defs.rs

@@ -4,8 +4,6 @@
 //@ normalize-stderr-test: "tests/rustdoc-ui/doctest" -> "$$DIR"
 //@ normalize-stdout-test: "finished in \d+\.\d+s" -> "finished in $$TIME"
 
-#![doc(test(attr(warn(non_local_definitions))))]
-
 //! ```
 //! #[macro_export]
 //! macro_rules! a_macro { () => {} }

tests/rustdoc-ui/doctest/non_local_defs.stderr

@@ -1,5 +1,5 @@
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
-  --> $DIR/non_local_defs.rs:11:1
+  --> $DIR/non_local_defs.rs:9:1
    |
 LL | macro_rules! a_macro { () => {} }
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,11 +7,7 @@ LL | macro_rules! a_macro { () => {} }
    = help: remove the `#[macro_export]` or make this doc-test a standalone test with its own `fn main() { ... }`
    = note: a `macro_rules!` definition is non-local if it is nested inside an item and has a `#[macro_export]` attribute
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/non_local_defs.rs:8:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: 1 warning emitted
 

tests/rustdoc-ui/doctest/non_local_defs.stdout

@@ -1,6 +1,6 @@
 
 running 1 test
-test $DIR/non_local_defs.rs - (line 9) ... ok
+test $DIR/non_local_defs.rs - (line 7) ... ok
 
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in $TIME
 

tests/ui/lint/non-local-defs/cargo-update.rs

@@ -10,8 +10,6 @@
 // of the `cargo update` suggestion we assert it here.
 //@ error-pattern: `cargo update -p non_local_macro`
 
-#![warn(non_local_definitions)]
-
 extern crate non_local_macro;
 
 struct LocalStruct;

tests/ui/lint/non-local-defs/cargo-update.stderr

@@ -1,5 +1,5 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/cargo-update.rs:19:1
+  --> $DIR/cargo-update.rs:17:1
    |
 LL | non_local_macro::non_local_impl!(LocalStruct);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -10,15 +10,10 @@ LL | non_local_macro::non_local_impl!(LocalStruct);
    |
    = note: the macro `non_local_macro::non_local_impl` defines the non-local `impl`, and may need to be changed
    = note: the macro `non_local_macro::non_local_impl` may come from an old version of the `non_local_macro` crate, try updating your dependency with `cargo update -p non_local_macro`
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/cargo-update.rs:13:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this warning originates in the macro `non_local_macro::non_local_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: 1 warning emitted

tests/ui/lint/non-local-defs/consts.rs

@@ -2,8 +2,6 @@
 //@ edition:2021
 //@ rustc-env:CARGO_CRATE_NAME=non_local_def
 
-#![warn(non_local_definitions)]
-
 struct Test;
 
 trait Uto {}

tests/ui/lint/non-local-defs/consts.stderr

@@ -1,5 +1,5 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:15:5
+  --> $DIR/consts.rs:13:5
    |
 LL | const Z: () = {
    | -----------
@@ -8,23 +8,18 @@ LL | const Z: () = {
    | move the `impl` block outside of this constant `Z`
 ...
 LL |     impl Uto for &Test {}
-   |     ^^^^^---^^^^^-----
+   |     ^^^^^---^^^^^^----
    |          |        |
-   |          |       `&'_ Test` is not local
+   |          |        `Test` is not local
    |          `Uto` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/consts.rs:5:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:26:5
+  --> $DIR/consts.rs:24:5
    |
 LL | static A: u32 = {
    | ------------- move the `impl` block outside of this static `A`
@@ -34,13 +29,12 @@ LL |     impl Uto2 for Test {}
    |          |        `Test` is not local
    |          `Uto2` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:34:5
+  --> $DIR/consts.rs:32:5
    |
 LL | const B: u32 = {
    | ------------ move the `impl` block outside of this constant `B`
@@ -50,13 +44,12 @@ LL |     impl Uto3 for Test {}
    |          |        `Test` is not local
    |          `Uto3` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:45:5
+  --> $DIR/consts.rs:43:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -65,11 +58,11 @@ LL |     impl Test {
    |          |
    |          `Test` is not local
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:52:9
+  --> $DIR/consts.rs:50:9
    |
 LL |       const {
    |  ___________-
@@ -84,11 +77,11 @@ LL | |         1
 LL | |     };
    | |_____- move the `impl` block outside of this inline constant `<unnameable>` and up 2 bodies
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:61:9
+  --> $DIR/consts.rs:59:9
    |
 LL |     const _: u32 = {
    |     ------------ move the `impl` block outside of this constant `_` and up 2 bodies
@@ -97,12 +90,12 @@ LL |         impl Test {
    |              |
    |              `Test` is not local
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: items in an anonymous const item (`const _: () = { ... }`) are treated as in the same scope as the anonymous const's declaration for the purpose of this lint
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:74:9
+  --> $DIR/consts.rs:72:9
    |
 LL |     let _a = || {
    |              -- move the `impl` block outside of this closure `<unnameable>` and up 2 bodies
@@ -112,12 +105,11 @@ LL |         impl Uto9 for Test {}
    |              |        `Test` is not local
    |              `Uto9` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/consts.rs:81:9
+  --> $DIR/consts.rs:79:9
    |
 LL |       type A = [u32; {
    |  ____________________-
@@ -131,7 +123,6 @@ LL | |
 LL | |     }];
    | |_____- move the `impl` block outside of this constant expression `<unnameable>` and up 2 bodies
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 

tests/ui/lint/non-local-defs/exhaustive-trait.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 struct Dog;
 
 fn main() {

tests/ui/lint/non-local-defs/exhaustive-trait.stderr

@@ -1,5 +1,5 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:9:5
+  --> $DIR/exhaustive-trait.rs:7:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -9,92 +9,84 @@ LL |     impl PartialEq<()> for Dog {
    |          |                 `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/exhaustive-trait.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:16:5
+  --> $DIR/exhaustive-trait.rs:14:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl PartialEq<()> for &Dog {
-   |     ^^^^^---------^^^^^^^^^----
+   |     ^^^^^---------^^^^^^^^^^---
    |          |                  |
-   |          |                 `&'_ Dog` is not local
+   |          |                  `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:23:5
+  --> $DIR/exhaustive-trait.rs:21:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl PartialEq<Dog> for () {
-   |     ^^^^^---------^^^^^^^^^^--
+   |     ^^^^^---------^---^^^^^^^^
    |          |         |
-   |          |                  `()` is not local
+   |          |         `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:30:5
+  --> $DIR/exhaustive-trait.rs:28:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl PartialEq<&Dog> for () {
-   |     ^^^^^---------^^^^^^^^^^^--
+   |     ^^^^^---------^^---^^^^^^^^
    |          |          |
-   |          |                   `()` is not local
+   |          |          `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:37:5
+  --> $DIR/exhaustive-trait.rs:35:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl PartialEq<Dog> for &Dog {
-   |     ^^^^^---------^^^^^^^^^^----
+   |     ^^^^^---------^---^^^^^^^---
-   |          |                  |
+   |          |         |         |
-   |          |                  `&'_ Dog` is not local
+   |          |         |         `Dog` is not local
+   |          |         `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive-trait.rs:44:5
+  --> $DIR/exhaustive-trait.rs:42:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl PartialEq<&Dog> for &Dog {
-   |     ^^^^^---------^^^^^^^^^^^----
+   |     ^^^^^---------^^---^^^^^^^---
-   |          |                   |
+   |          |          |         |
-   |          |                   `&'_ Dog` is not local
+   |          |          |         `Dog` is not local
+   |          |          `Dog` is not local
    |          `PartialEq` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 

tests/ui/lint/non-local-defs/exhaustive.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 use std::fmt::Display;
 
 trait Trait {}
@@ -57,18 +55,13 @@ fn main() {
 
     struct InsideMain;
 
+    impl Trait for &InsideMain {}
     impl Trait for *mut InsideMain {}
-    //~^ WARN non-local `impl` definition
     impl Trait for *mut [InsideMain] {}
-    //~^ WARN non-local `impl` definition
     impl Trait for [InsideMain; 8] {}
-    //~^ WARN non-local `impl` definition
     impl Trait for (InsideMain,) {}
-    //~^ WARN non-local `impl` definition
     impl Trait for fn(InsideMain) -> () {}
-    //~^ WARN non-local `impl` definition
     impl Trait for fn() -> InsideMain {}
-    //~^ WARN non-local `impl` definition
 
     fn inside_inside() {
         impl Display for InsideMain {

tests/ui/lint/non-local-defs/exhaustive.stderr

@@ -1,5 +1,5 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:12:5
+  --> $DIR/exhaustive.rs:10:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -8,16 +8,12 @@ LL |     impl Test {
    |          |
    |          `Test` is not local
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/exhaustive.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:17:5
+  --> $DIR/exhaustive.rs:15:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -28,12 +24,11 @@ LL |     impl Display for Test {
    |          |           `Test` is not local
    |          `Display` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:24:5
+  --> $DIR/exhaustive.rs:22:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -43,11 +38,11 @@ LL |     impl dyn Trait {}
    |              |
    |              `Trait` is not local
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:27:5
+  --> $DIR/exhaustive.rs:25:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
@@ -58,124 +53,116 @@ LL |     impl<T: Trait> Trait for Vec<T> { }
    |                    |         `Vec` is not local
    |                    `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:30:5
+  --> $DIR/exhaustive.rs:28:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for &dyn Trait {}
-   |     ^^^^^-----^^^^^----------
+   |     ^^^^^-----^^^^^^^^^^-----
    |          |              |
-   |          |         `&'_ dyn Trait` is not local
+   |          |              `Trait` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:33:5
+  --> $DIR/exhaustive.rs:31:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for *mut Test {}
-   |     ^^^^^-----^^^^^---------
+   |     ^^^^^-----^^^^^^^^^^----
    |          |              |
-   |          |         `*mut Test` is not local
+   |          |              `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:36:5
+  --> $DIR/exhaustive.rs:34:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for *mut [Test] {}
-   |     ^^^^^-----^^^^^-----------
+   |     ^^^^^-----^^^^^^^^^^^----^
    |          |               |
-   |          |         `*mut [Test]` is not local
+   |          |               `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:39:5
+  --> $DIR/exhaustive.rs:37:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for [Test; 8] {}
-   |     ^^^^^-----^^^^^---------
+   |     ^^^^^-----^^^^^^----^^^^
    |          |          |
-   |          |         `[Test; 8]` is not local
+   |          |          `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:42:5
+  --> $DIR/exhaustive.rs:40:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for (Test,) {}
-   |     ^^^^^-----^^^^^-------
+   |     ^^^^^-----^^^^^^----^^
    |          |          |
-   |          |         `(Test,)` is not local
+   |          |          `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:45:5
+  --> $DIR/exhaustive.rs:43:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for fn(Test) -> () {}
-   |     ^^^^^-----^^^^^--------------
+   |     ^^^^^-----^^^^^^^^----^^^^^^^
    |          |            |
-   |          |         `fn(: Test) -> ()` is not local
+   |          |            `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:48:5
+  --> $DIR/exhaustive.rs:46:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 ...
 LL |     impl Trait for fn() -> Test {}
-   |     ^^^^^-----^^^^^------------
+   |     ^^^^^-----^^^^^^^^^^^^^----
    |          |                 |
-   |          |         `fn() -> Test` is not local
+   |          |                 `Test` is not local
    |          `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:52:9
+  --> $DIR/exhaustive.rs:50:9
    |
 LL |     let _a = || {
    |              -- move the `impl` block outside of this closure `<unnameable>` and up 2 bodies
@@ -185,139 +172,11 @@ LL |         impl Trait for Test {}
    |              |         `Test` is not local
    |              `Trait` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:60:5
+  --> $DIR/exhaustive.rs:67:9
-   |
-LL |     impl Trait for *mut InsideMain {}
-   |     ^^^^^-----^^^^^---------------
-   |          |         |
-   |          |         `*mut InsideMain` is not local
-   |          |         help: remove `*mut ` to make the `impl` local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:62:5
-   |
-LL |     impl Trait for *mut [InsideMain] {}
-   |     ^^^^^-----^^^^^-----------------
-   |          |         |
-   |          |         `*mut [InsideMain]` is not local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:64:5
-   |
-LL |     impl Trait for [InsideMain; 8] {}
-   |     ^^^^^-----^^^^^---------------
-   |          |         |
-   |          |         `[InsideMain; 8]` is not local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:66:5
-   |
-LL |     impl Trait for (InsideMain,) {}
-   |     ^^^^^-----^^^^^-------------
-   |          |         |
-   |          |         `(InsideMain,)` is not local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:68:5
-   |
-LL |     impl Trait for fn(InsideMain) -> () {}
-   |     ^^^^^-----^^^^^--------------------
-   |          |         |
-   |          |         `fn(: InsideMain) -> ()` is not local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:70:5
-   |
-LL |     impl Trait for fn() -> InsideMain {}
-   |     ^^^^^-----^^^^^------------------
-   |          |         |
-   |          |         `fn() -> InsideMain` is not local
-   |          `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/exhaustive.rs:11:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:74:9
    |
 LL |     fn inside_inside() {
    |     ------------------ move the `impl` block outside of this function `inside_inside` and up 2 bodies
@@ -327,12 +186,11 @@ LL |         impl Display for InsideMain {
    |              |           `InsideMain` is not local
    |              `Display` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/exhaustive.rs:81:9
+  --> $DIR/exhaustive.rs:74:9
    |
 LL |     fn inside_inside() {
    |     ------------------ move the `impl` block outside of this function `inside_inside` and up 2 bodies
@@ -342,8 +200,8 @@ LL |         impl InsideMain {
    |              |
    |              `InsideMain` is not local
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
-warning: 20 warnings emitted
+warning: 14 warnings emitted
 

tests/ui/lint/non-local-defs/from-local-for-global.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 struct Cat;
 struct Wrap<T>(T);
 
@@ -18,7 +16,6 @@ fn main() {
     struct Elephant;
 
     impl From<Wrap<Wrap<Elephant>>> for () {
-    //~^ WARN non-local `impl` definition
         fn from(_: Wrap<Wrap<Elephant>>) -> Self {
             todo!()
         }
@@ -32,7 +29,6 @@ impl StillNonLocal for &str {}
 fn only_global() {
     struct Foo;
     impl StillNonLocal for &Foo {}
-    //~^ WARN non-local `impl` definition
 }
 
 struct GlobalSameFunction;
@@ -40,7 +36,6 @@ struct GlobalSameFunction;
 fn same_function() {
     struct Local1(GlobalSameFunction);
     impl From<Local1> for GlobalSameFunction {
-    //~^ WARN non-local `impl` definition
         fn from(x: Local1) -> GlobalSameFunction {
             x.0
         }
@@ -48,7 +43,6 @@ fn same_function() {
 
     struct Local2(GlobalSameFunction);
     impl From<Local2> for GlobalSameFunction {
-    //~^ WARN non-local `impl` definition
         fn from(x: Local2) -> GlobalSameFunction {
             x.0
         }
@@ -61,8 +55,6 @@ fn diff_function_1() {
     struct Local(GlobalDifferentFunction);
 
     impl From<Local> for GlobalDifferentFunction {
-    // FIXME(Urgau): Should warn but doesn't since we currently consider
-    // the other impl to be "global", but that's not the case for the type-system
         fn from(x: Local) -> GlobalDifferentFunction {
             x.0
         }
@@ -73,8 +65,6 @@ fn diff_function_2() {
     struct Local(GlobalDifferentFunction);
 
     impl From<Local> for GlobalDifferentFunction {
-    // FIXME(Urgau): Should warn but doesn't since we currently consider
-    // the other impl to be "global", but that's not the case for the type-system
         fn from(x: Local) -> GlobalDifferentFunction {
             x.0
         }

tests/ui/lint/non-local-defs/from-local-for-global.stderr

@@ -1,104 +1,17 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/from-local-for-global.rs:10:5
+  --> $DIR/from-local-for-global.rs:8:5
    |
 LL | fn main() {
    | --------- move the `impl` block outside of this function `main`
 LL |     impl From<Cat> for () {
-   |     ^^^^^----^^^^^^^^^^--
+   |     ^^^^^----^---^^^^^^^^
    |          |    |
-   |          |             `()` is not local
+   |          |    `Cat` is not local
    |          `From` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/from-local-for-global.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
+warning: 1 warning emitted
-  --> $DIR/from-local-for-global.rs:20:5
-   |
-LL |     impl From<Wrap<Wrap<Elephant>>> for () {
-   |     ^^^^^----^^^^^^^^^^^^^^^^^^^^^^^^^^^--
-   |          |                              |
-   |          `From` is not local            `()` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/from-local-for-global.rs:9:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-...
-LL |     struct Elephant;
-   |     --------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/from-local-for-global.rs:34:5
-   |
-LL |     impl StillNonLocal for &Foo {}
-   |     ^^^^^-------------^^^^^----
-   |          |                 |
-   |          |                 `&'_ Foo` is not local
-   |          |                 help: remove `&` to make the `impl` local
-   |          `StillNonLocal` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `only_global`
-  --> $DIR/from-local-for-global.rs:32:1
-   |
-LL | fn only_global() {
-   | ^^^^^^^^^^^^^^^^
-LL |     struct Foo;
-   |     ---------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/from-local-for-global.rs:42:5
-   |
-LL |     impl From<Local1> for GlobalSameFunction {
-   |     ^^^^^----^^^^^^^^^^^^^------------------
-   |          |                |
-   |          |                `GlobalSameFunction` is not local
-   |          `From` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `same_function`
-  --> $DIR/from-local-for-global.rs:40:1
-   |
-LL | fn same_function() {
-   | ^^^^^^^^^^^^^^^^^^
-LL |     struct Local1(GlobalSameFunction);
-   |     ------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/from-local-for-global.rs:50:5
-   |
-LL |     impl From<Local2> for GlobalSameFunction {
-   |     ^^^^^----^^^^^^^^^^^^^------------------
-   |          |                |
-   |          |                `GlobalSameFunction` is not local
-   |          `From` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `same_function`
-  --> $DIR/from-local-for-global.rs:40:1
-   |
-LL | fn same_function() {
-   | ^^^^^^^^^^^^^^^^^^
-...
-LL |     struct Local2(GlobalSameFunction);
-   |     ------------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: 5 warnings emitted
 

tests/ui/lint/non-local-defs/generics.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 trait Global {}
 
 fn main() {
@@ -32,7 +30,6 @@ fn fun() {
     #[derive(Debug)]
     struct OwO;
     impl Default for UwU<OwO> {
-    //~^ WARN non-local `impl` definition
         fn default() -> Self {
             UwU(OwO)
         }
@@ -43,7 +40,6 @@ fn meow() {
     #[derive(Debug)]
     struct Cat;
     impl AsRef<Cat> for () {
-    //~^ WARN non-local `impl` definition
         fn as_ref(&self) -> &Cat { &Cat }
     }
 }
@@ -54,7 +50,6 @@ fn fun2() {
     #[derive(Debug, Default)]
     struct B;
     impl PartialEq<B> for G {
-    //~^ WARN non-local `impl` definition
         fn eq(&self, _: &B) -> bool {
             true
         }
@@ -69,14 +64,12 @@ fn rawr() {
     struct Lion;
 
     impl From<Wrap<Wrap<Lion>>> for () {
-    //~^ WARN non-local `impl` definition
         fn from(_: Wrap<Wrap<Lion>>) -> Self {
             todo!()
         }
     }
 
     impl From<()> for Wrap<Lion> {
-    //~^ WARN non-local `impl` definition
         fn from(_: ()) -> Self {
             todo!()
         }

tests/ui/lint/non-local-defs/generics.stderr

@@ -1,165 +1,47 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:11:5
+  --> $DIR/generics.rs:9:5
    |
+LL | fn main() {
+   | --------- move the `impl` block outside of this function `main`
+...
 LL |     impl<T: Local> Global for Vec<T> { }
    |     ^^^^^^^^^^^^^^^------^^^^^---^^^
    |                    |          |
    |                    |          `Vec` is not local
    |                    `Global` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/generics.rs:8:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-LL |     trait Local {};
-   |     ----------- may need to be moved as well
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/generics.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:22:5
+  --> $DIR/generics.rs:20:5
    |
+LL | fn bad() {
+   | -------- move the `impl` block outside of this function `bad`
+LL |     struct Local;
 LL |     impl Uto7 for Test where Local: std::any::Any {}
    |     ^^^^^----^^^^^----
    |          |        |
    |          |        `Test` is not local
    |          `Uto7` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `bad`
-  --> $DIR/generics.rs:20:1
-   |
-LL | fn bad() {
-   | ^^^^^^^^
-LL |     struct Local;
-   |     ------------ may need to be moved as well
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:25:5
+  --> $DIR/generics.rs:23:5
    |
 LL | fn bad() {
    | -------- move the `impl` block outside of this function `bad`
 ...
 LL |     impl<T> Uto8 for T {}
-   |     ^^^^^^^^----^^^^^-
+   |     ^^^^^^^^----^^^^^^
-   |             |        |
+   |             |
-   |             |        `T` is not local
    |             `Uto8` is not local
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
+warning: 3 warnings emitted
-  --> $DIR/generics.rs:34:5
-   |
-LL |     impl Default for UwU<OwO> {
-   |     ^^^^^-------^^^^^---^^^^^
-   |          |           |
-   |          |           `UwU` is not local
-   |          `Default` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `fun`
-  --> $DIR/generics.rs:31:1
-   |
-LL | fn fun() {
-   | ^^^^^^^^
-LL |     #[derive(Debug)]
-LL |     struct OwO;
-   |     ---------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:45:5
-   |
-LL |     impl AsRef<Cat> for () {
-   |     ^^^^^-----^^^^^^^^^^--
-   |          |              |
-   |          |              `()` is not local
-   |          `AsRef` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `meow`
-  --> $DIR/generics.rs:42:1
-   |
-LL | fn meow() {
-   | ^^^^^^^^^
-LL |     #[derive(Debug)]
-LL |     struct Cat;
-   |     ---------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:56:5
-   |
-LL |     impl PartialEq<B> for G {
-   |     ^^^^^---------^^^^^^^^-
-   |          |                |
-   |          |                `G` is not local
-   |          `PartialEq` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `fun2`
-  --> $DIR/generics.rs:53:1
-   |
-LL | fn fun2() {
-   | ^^^^^^^^^
-LL |     #[derive(Debug, Default)]
-LL |     struct B;
-   |     -------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:71:5
-   |
-LL |     impl From<Wrap<Wrap<Lion>>> for () {
-   |     ^^^^^----^^^^^^^^^^^^^^^^^^^^^^^--
-   |          |                          |
-   |          `From` is not local        `()` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `rawr`
-  --> $DIR/generics.rs:68:1
-   |
-LL | fn rawr() {
-   | ^^^^^^^^^
-LL |     struct Lion;
-   |     ----------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/generics.rs:78:5
-   |
-LL |     impl From<()> for Wrap<Lion> {
-   |     ^^^^^----^^^^^^^^^----^^^^^^
-   |          |            |
-   |          |            `Wrap` is not local
-   |          `From` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `rawr`
-  --> $DIR/generics.rs:68:1
-   |
-LL | fn rawr() {
-   | ^^^^^^^^^
-LL |     struct Lion;
-   |     ----------- may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-
-warning: 8 warnings emitted
 

tests/ui/lint/non-local-defs/inside-macro_rules.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 macro_rules! m {
     () => {
         trait MacroTrait {}

tests/ui/lint/non-local-defs/inside-macro_rules.stderr

@@ -1,5 +1,5 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/inside-macro_rules.rs:11:13
+  --> $DIR/inside-macro_rules.rs:9:13
    |
 LL |         fn my_func() {
    |         ------------ move the `impl` block outside of this function `my_func`
@@ -13,14 +13,9 @@ LL | m!();
    | ---- in this macro invocation
    |
    = note: the macro `m` defines the non-local `impl`, and may need to be changed
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/inside-macro_rules.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
    = note: this warning originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: 1 warning emitted

tests/ui/lint/non-local-defs/local.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 use std::fmt::Debug;
 
 trait GlobalTrait {}

tests/ui/lint/non-local-defs/macro_rules.rs

@@ -3,8 +3,6 @@
 //@ aux-build:non_local_macro.rs
 //@ rustc-env:CARGO_CRATE_NAME=non_local_def
 
-#![warn(non_local_definitions)]
-
 extern crate non_local_macro;
 
 const B: u32 = {

tests/ui/lint/non-local-defs/macro_rules.stderr

@@ -1,5 +1,5 @@
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
-  --> $DIR/macro_rules.rs:12:5
+  --> $DIR/macro_rules.rs:10:5
    |
 LL |     macro_rules! m0 { () => { } };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,14 +7,10 @@ LL |     macro_rules! m0 { () => { } };
    = help: remove the `#[macro_export]` or move this `macro_rules!` outside the of the current constant `B`
    = note: a `macro_rules!` definition is non-local if it is nested inside an item and has a `#[macro_export]` attribute
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/macro_rules.rs:6:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
-  --> $DIR/macro_rules.rs:18:1
+  --> $DIR/macro_rules.rs:16:1
    |
 LL | non_local_macro::non_local_macro_rules!(my_macro);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -26,7 +22,7 @@ LL | non_local_macro::non_local_macro_rules!(my_macro);
    = note: this warning originates in the macro `non_local_macro::non_local_macro_rules` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
-  --> $DIR/macro_rules.rs:23:5
+  --> $DIR/macro_rules.rs:21:5
    |
 LL |     macro_rules! m { () => { } };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +32,7 @@ LL |     macro_rules! m { () => { } };
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `macro_rules!` definition, `#[macro_export]` macro should be written at top level module
-  --> $DIR/macro_rules.rs:31:13
+  --> $DIR/macro_rules.rs:29:13
    |
 LL |             macro_rules! m2 { () => { } };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

tests/ui/lint/non-local-defs/ref-complex.rs

@@ -1,7 +1,5 @@
 //@ check-pass
 
-#![warn(non_local_definitions)]
-
 trait Trait<T> {}
 
 fn main() {
@@ -12,7 +10,6 @@ fn main() {
     trait HasFoo {}
 
     impl<T> Trait<InsideMain> for &Vec<below::Type<(InsideMain, T)>>
-    //~^ WARN non-local `impl` definition
     where
         T: HasFoo
     {}

tests/ui/lint/non-local-defs/suggest-moving-inner.stderr

@@ -1,33 +0,0 @@
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/suggest-moving-inner.rs:14:5
-   |
-LL |     impl<T> Trait<InsideMain> for &Vec<below::Type<(InsideMain, T)>>
-   |     ^^^^^^^^-----^^^^^^^^^^^^^^^^^----------------------------------
-   |             |                     |
-   |             |                     `&'_ Vec<below::Type<(InsideMain, T)>>` is not local
-   |             `Trait` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/suggest-moving-inner.rs:7:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-LL |     mod below {
-LL |         pub struct Type<T>(T);
-   |         ------------------ may need to be moved as well
-LL |     }
-LL |     struct InsideMain;
-   |     ----------------- may need to be moved as well
-LL |     trait HasFoo {}
-   |     ------------ may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
-  --> $DIR/suggest-moving-inner.rs:3:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
-
-warning: 1 warning emitted
-

tests/ui/lint/non-local-defs/trait-solver-overflow-123573.rs

@@ -3,8 +3,6 @@
 
 // https://github.com/rust-lang/rust/issues/123573#issue-2229428739
 
-#![warn(non_local_definitions)]
-
 pub trait Test {}
 
 impl<'a, T: 'a> Test for &[T] where &'a T: Test {}
@@ -12,5 +10,4 @@ impl<'a, T: 'a> Test for &[T] where &'a T: Test {}
 fn main() {
     struct Local {}
     impl Test for &Local {}
-    //~^ WARN non-local `impl` definition
 }

tests/ui/lint/non-local-defs/trait-solver-overflow-123573.stderr

@@ -1,28 +0,0 @@
-warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/trait-solver-overflow-123573.rs:14:5
-   |
-LL |     impl Test for &Local {}
-   |     ^^^^^----^^^^^------
-   |          |        |
-   |          |        `&'_ Local` is not local
-   |          |        help: remove `&` to make the `impl` local
-   |          `Test` is not local
-   |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
-   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
-help: move the `impl` block outside of this function `main`
-  --> $DIR/trait-solver-overflow-123573.rs:12:1
-   |
-LL | fn main() {
-   | ^^^^^^^^^
-LL |     struct Local {}
-   |     ------------ may need to be moved as well
-   = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
-  --> $DIR/trait-solver-overflow-123573.rs:6:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
-
-warning: 1 warning emitted
-

tests/ui/lint/non-local-defs/weird-exprs.rs

@@ -1,8 +1,6 @@
 //@ check-pass
 //@ edition:2021
 
-#![warn(non_local_definitions)]
-
 trait Uto {}
 struct Test;
 

tests/ui/lint/non-local-defs/weird-exprs.stderr

@@ -1,29 +1,24 @@
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:10:5
+  --> $DIR/weird-exprs.rs:8:5
    |
 LL |   type A = [u32; {
    |  ________________-
 LL | |     impl Uto for *mut Test {}
-   | |     ^^^^^---^^^^^---------
+   | |     ^^^^^---^^^^^^^^^^----
    | |          |            |
-   | |          |       `*mut Test` is not local
+   | |          |            `Test` is not local
    | |          `Uto` is not local
 LL | |
 ...  |
 LL | | }];
    | |_- move the `impl` block outside of this constant expression `<unnameable>`
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
-note: the lint level is defined here
+   = note: `#[warn(non_local_definitions)]` on by default
-  --> $DIR/weird-exprs.rs:4:9
-   |
-LL | #![warn(non_local_definitions)]
-   |         ^^^^^^^^^^^^^^^^^^^^^
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:18:9
+  --> $DIR/weird-exprs.rs:16:9
    |
 LL |       Discr = {
    |  _____________-
@@ -37,12 +32,11 @@ LL | |
 LL | |     }
    | |_____- move the `impl` block outside of this constant expression `<unnameable>`
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:27:9
+  --> $DIR/weird-exprs.rs:25:9
    |
 LL |       let _array = [0i32; {
    |  _________________________-
@@ -57,63 +51,61 @@ LL | |         1
 LL | |     }];
    | |_____- move the `impl` block outside of this constant expression `<unnameable>` and up 2 bodies
    |
-   = note: methods and associated constants are still usable outside the current expression, only `impl Local` and `impl dyn Local` can ever be private, and only if the type is nested in the same item as the `impl`
+   = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:36:9
+  --> $DIR/weird-exprs.rs:34:9
    |
 LL |       type A = [u32; {
    |  ____________________-
 LL | |         impl Uto for &Test {}
-   | |         ^^^^^---^^^^^-----
+   | |         ^^^^^---^^^^^^----
    | |              |        |
-   | |              |       `&'_ Test` is not local
+   | |              |        `Test` is not local
    | |              `Uto` is not local
 LL | |
 ...  |
 LL | |     }];
    | |_____- move the `impl` block outside of this constant expression `<unnameable>` and up 2 bodies
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:43:9
+  --> $DIR/weird-exprs.rs:41:9
    |
 LL |       fn a(_: [u32; {
    |  ___________________-
 LL | |         impl Uto for &(Test,) {}
-   | |         ^^^^^---^^^^^--------
+   | |         ^^^^^---^^^^^^^----^^
    | |              |         |
-   | |              |       `&'_ (Test,)` is not local
+   | |              |         `Test` is not local
    | |              `Uto` is not local
 LL | |
 ...  |
 LL | |     }]) {}
    | |_____- move the `impl` block outside of this constant expression `<unnameable>` and up 2 bodies
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>
 
 warning: non-local `impl` definition, `impl` blocks should be written at the same level as their item
-  --> $DIR/weird-exprs.rs:50:9
+  --> $DIR/weird-exprs.rs:48:9
    |
 LL |       fn b() -> [u32; {
    |  _____________________-
 LL | |         impl Uto for &(Test,Test) {}
-   | |         ^^^^^---^^^^^------------
+   | |         ^^^^^---^^^^^^^----^----^
-   | |              |       |
+   | |              |         |    |
-   | |              |       `&'_ (Test, Test)` is not local
+   | |              |         |    `Test` is not local
+   | |              |         `Test` is not local
    | |              `Uto` is not local
 LL | |
 ...  |
 LL | |     }] { todo!() }
    | |_____- move the `impl` block outside of this constant expression `<unnameable>` and up 2 bodies
    |
-   = note: `impl` may be usable in bounds, etc. from outside the expression, which might e.g. make something constructible that previously wasn't, because it's still on a publicly-visible type
    = note: an `impl` is never scoped, even when it is nested inside an item, as it may impact type checking outside of that item, which can be the case if neither the trait or the self type are at the same nesting level as the `impl`
    = note: this lint may become deny-by-default in the edition 2024 and higher, see the tracking issue <https://github.com/rust-lang/rust/issues/120363>