Implement RFC3373 non local definitions lint

Author: Urgau

compiler/rustc_lint/messages.ftl

@@ -406,6 +406,10 @@ lint_non_fmt_panic_unused =
     }
     .add_fmt_suggestion = or add a "{"{"}{"}"}" format string to use the message literally
 
+lint_non_local_definitions = non local definition should be avoided as they go against expectation
+    .help = move this declaration outside the of the {$depth} outermost bodies
+    .deprecation = this may become deny-by-default in the Edition 2024 and higher
+
 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/lib.rs

@@ -72,6 +72,7 @@ mod methods;
 mod multiple_supertrait_upcastable;
 mod non_ascii_idents;
 mod non_fmt_panic;
+mod non_local_def;
 mod nonstandard_style;
 mod noop_method_call;
 mod opaque_hidden_inferred_bound;
@@ -107,6 +108,7 @@ use methods::*;
 use multiple_supertrait_upcastable::*;
 use non_ascii_idents::*;
 use non_fmt_panic::NonPanicFmt;
+use non_local_def::*;
 use nonstandard_style::*;
 use noop_method_call::*;
 use opaque_hidden_inferred_bound::*;
@@ -233,6 +235,7 @@ late_lint_methods!(
             MissingDebugImplementations: MissingDebugImplementations,
             MissingDoc: MissingDoc,
             AsyncFnInTrait: AsyncFnInTrait,
+            NonLocalDefinitions: NonLocalDefinitions::default(),
         ]
     ]
 );

compiler/rustc_lint/src/lints.rs

@@ -1305,6 +1305,15 @@ pub struct SuspiciousDoubleRefCloneDiag<'a> {
     pub ty: Ty<'a>,
 }
 
+// non_local_defs.rs
+#[derive(LintDiagnostic)]
+#[diag(lint_non_local_definitions)]
+#[help(lint_help)]
+#[note(lint_deprecation)]
+pub struct NonLocalDefinitionsDiag {
+    pub depth: u32,
+}
+
 // pass_by_value.rs
 #[derive(LintDiagnostic)]
 #[diag(lint_pass_by_value)]

compiler/rustc_lint/src/non_local_def.rs

@@ -0,0 +1,89 @@
+use rustc_hir::{Body, Item, ItemKind, QPath, TyKind};
+use rustc_span::{sym, MacroKind};
+
+use crate::{lints::NonLocalDefinitionsDiag, LateContext, LateLintPass, LintContext};
+
+declare_lint! {
+    /// The `non_local_definitions` lint checks for `impl` blocks and `#[macro_export]`
+    /// macro inside bodies (functions, enum discriminant, ...).
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// trait MyTrait {}
+    /// struct MyStruct;
+    ///
+    /// fn foo() {
+    ///     impl MyTrait for MyStruct {}
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// Creating non local definitions go against expectation and can create decrepencies
+    /// in tooling. In should be avoided.
+    pub NON_LOCAL_DEFINITIONS,
+    Warn,
+    "checks for non local definitions"
+}
+
+#[derive(Default)]
+pub struct NonLocalDefinitions {
+    is_in_body: u32,
+}
+
+impl_lint_pass!(NonLocalDefinitions => [NON_LOCAL_DEFINITIONS]);
+
+impl<'tcx> LateLintPass<'tcx> for NonLocalDefinitions {
+    fn check_body(&mut self, _cx: &LateContext<'tcx>, _body: &'tcx Body<'tcx>) {
+        self.is_in_body += 1;
+    }
+
+    fn check_body_post(&mut self, _cx: &LateContext<'tcx>, _body: &'tcx Body<'tcx>) {
+        self.is_in_body -= 1;
+    }
+
+    fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx Item<'tcx>) {
+        if self.is_in_body > 0 {
+            match item.kind {
+                ItemKind::Impl(impl_) => 'block: {
+                    let TyKind::Path(QPath::Resolved(_, self_ty_path)) = impl_.self_ty.kind else {
+                        break 'block;
+                    };
+                    let Some(self_ty_did) = self_ty_path.res.opt_def_id() else {
+                        break 'block;
+                    };
+                    let parent_self_ty = cx.tcx.parent(self_ty_did);
+
+                    let parent_impl = cx.tcx.parent(item.owner_id.def_id.into());
+                    if parent_impl != parent_self_ty
+                        && impl_
+                            .of_trait
+                            .map(|trait_| trait_.trait_def_id())
+                            .flatten()
+                            .map(|did| cx.tcx.parent(did) != parent_impl)
+                            .unwrap_or(true)
+                    {
+                        cx.emit_span_lint(
+                            NON_LOCAL_DEFINITIONS,
+                            item.span,
+                            NonLocalDefinitionsDiag { depth: self.is_in_body },
+                        );
+                    }
+                }
+                ItemKind::Macro(_macro, MacroKind::Bang) => {
+                    if cx.tcx.has_attr(item.owner_id.def_id, sym::macro_export) {
+                        cx.emit_span_lint(
+                            NON_LOCAL_DEFINITIONS,
+                            item.span,
+                            NonLocalDefinitionsDiag { depth: self.is_in_body },
+                        );
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+}

tests/ui/lint/non_local_definitions.rs

@@ -0,0 +1,137 @@
+// check-pass
+// edition:2021
+
+#![feature(inline_const)]
+
+use std::fmt::{Debug, Display};
+
+struct Test;
+
+impl Debug for Test {
+    fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}
+
+mod do_not_lint_mod {
+    pub trait Tait {}
+
+    impl super::Test {
+        fn hugo() {}
+    }
+
+    impl Tait for super::Test {}
+}
+
+const _: () = {
+    trait Uto {}
+
+    impl Uto for Test {} // the trait is local, don't lint
+};
+
+trait Uto1 {}
+enum Enum {
+    Discr = {
+        impl Uto1 for Test {}
+        //~^ WARN non local definition
+
+        1
+    }
+}
+
+trait Uto2 {}
+static A: u32 = {
+    impl Uto2 for Test {}
+    //~^ WARN non local definition
+
+    1
+};
+
+trait Uto3 {}
+const B: u32 = {
+    impl Uto3 for Test {}
+    //~^ WARN non local definition
+
+    #[macro_export]
+    macro_rules! m0 { () => { } };
+    //~^ WARN non local definition
+
+    trait Uto4 {}
+    impl Uto4 for Test {}
+
+    1
+};
+
+trait Uto5 {}
+fn main() {
+    #[macro_export]
+    macro_rules! m { () => { } };
+    //~^ WARN non local definition
+
+    impl Test {
+    //~^ WARN non local definition
+        fn foo() {}
+    }
+
+    let _array = [0i32; {
+        impl Test {
+        //~^ WARN non local definition
+            fn bar() {}
+        }
+
+        1
+    }];
+
+    const {
+        impl Test {
+        //~^ WARN non local definition
+            fn hoo() {}
+        }
+
+        1
+    };
+
+    impl Display for Test {
+    //~^ WARN non local definition
+        fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    let _a = || {
+        impl Uto5 for Test {}
+        //~^ WARN non local definition
+
+        1
+    };
+
+    struct InsideMain;
+
+    impl Debug for InsideMain {
+        fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            todo!()
+        }
+    }
+
+    impl InsideMain {
+        fn foo() {}
+    }
+
+    fn inside_inside() {
+        impl Display for InsideMain {
+        //~^ WARN non local definition
+            fn fmt(&self, _f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+                todo!()
+            }
+        }
+
+        impl InsideMain {
+        //~^ WARN non local definition
+            fn bar() {
+                #[macro_export]
+                macro_rules! m2 { () => { } };
+                //~^ WARN non local definition
+            }
+        }
+    }
+}