addind new lint

Author: mdietz94

compiler/rustc_lint_defs/src/builtin.rs

@@ -1703,6 +1703,39 @@ declare_lint! {
     "functions that cannot return without calling themselves"
 }
 
+declare_lint! {
+    /// The `recursive_dafault_impl` lint detects functions that cannot
+    /// return without calling themselves.
+    ///
+    /// ### Example
+    ///
+    /// ```rust
+    /// struct Foo {
+    ///     bar: u32
+    /// }
+    /// impl Default for Foo {
+    ///     fn default() -> Self {
+    ///         Self {
+    ///             ..Default::default()
+    ///         }
+    /// }
+    ///
+    /// let _ = Foo::default();
+    /// ```
+    ///
+    /// {{produces}}
+    ///
+    /// ### Explanation
+    ///
+    /// This is a specific case of unconditional recursion where the default
+    /// trait is implemented recursively, errantly trying to apply the
+    /// default struct for this field. This will always lead to an infinite loop
+    /// so it is denied.
+    pub RECURSIVE_DEFAULT_IMPL,
+    Deny,
+    "functions that cannot return without calling themselves"
+}
+
 declare_lint! {
     /// The `single_use_lifetimes` lint detects lifetimes that are only used
     /// once.

compiler/rustc_mir_build/messages.ftl

@@ -265,6 +265,12 @@ mir_build_pointer_pattern = function pointers and raw pointers not derived from
 
 mir_build_privately_uninhabited = pattern `{$witness_1}` is currently uninhabited, but this variant contains private fields which may become inhabited in the future
 
+mir_build_recursive_default_impl = recursive default impl
+    .label = will result in infinite recursion
+    .help = ..default() in the Default impl does not apply a default for each struct field
+
+mir_build_recursive_default_impl_call_site_label = recursive call site
+
 mir_build_rust_2024_incompatible_pat = the semantics of this pattern will change in edition 2024
 
 mir_build_rustc_box_attribute_error = `#[rustc_box]` attribute used incorrectly
@@ -313,6 +319,7 @@ mir_build_unconditional_recursion = function cannot return without recursing
 
 mir_build_unconditional_recursion_call_site_label = recursive call site
 
+
 mir_build_union_field_requires_unsafe =
     access to union field is unsafe and requires unsafe block
     .note = the field may not be properly initialized: using uninitialized data will cause undefined behavior

compiler/rustc_mir_build/src/errors.rs

@@ -12,6 +12,16 @@ use rustc_span::Span;
 
 use crate::fluent_generated as fluent;
 
+#[derive(LintDiagnostic)]
+#[diag(mir_build_recursive_default_impl)]
+#[help]
+pub(crate) struct RecursiveDefaultImpl {
+    #[label]
+    pub(crate) span: Span,
+    #[label(mir_build_recursive_default_impl_call_site_label)]
+    pub(crate) call_sites: Vec<Span>,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(mir_build_unconditional_recursion)]
 #[help]

compiler/rustc_mir_build/src/lints.rs

@@ -6,10 +6,10 @@ use rustc_data_structures::graph::iterate::{
 use rustc_hir::def::DefKind;
 use rustc_middle::mir::{self, BasicBlock, BasicBlocks, Body, Terminator, TerminatorKind};
 use rustc_middle::ty::{self, GenericArg, GenericArgs, Instance, Ty, TyCtxt};
-use rustc_session::lint::builtin::UNCONDITIONAL_RECURSION;
-use rustc_span::Span;
+use rustc_session::lint::builtin::{RECURSIVE_DEFAULT_IMPL, UNCONDITIONAL_RECURSION};
+use rustc_span::{sym, Span};
 
-use crate::errors::UnconditionalRecursion;
+use crate::errors::{RecursiveDefaultImpl, UnconditionalRecursion};
 
 pub(crate) fn check<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>) {
     check_call_recursion(tcx, body);
@@ -49,11 +49,29 @@ fn check_recursion<'tcx>(
         if vis.reachable_recursive_calls.is_empty() {
             return;
         }
-
         vis.reachable_recursive_calls.sort();
-
         let sp = tcx.def_span(def_id);
         let hir_id = tcx.local_def_id_to_hir_id(def_id);
+        // emit a different error for recursive default impls
+        if tcx.def_kind(def_id) == DefKind::AssocFn {
+            // Check if this is a trait impl and get the defid of the trait if it is
+            if let Some(trait_def_id) = tcx.trait_id_of_impl(tcx.parent(def_id.into())) {
+                // check if it is a default impl
+                if tcx.get_diagnostic_name(trait_def_id) == Some(sym::Default) {
+                    tcx.emit_node_span_lint(
+                        RECURSIVE_DEFAULT_IMPL,
+                        hir_id,
+                        sp,
+                        RecursiveDefaultImpl {
+                            span: sp,
+                            call_sites: vis.reachable_recursive_calls,
+                        },
+                    );
+                    return;
+                }
+            }
+        }
+
         tcx.emit_node_span_lint(
             UNCONDITIONAL_RECURSION,
             hir_id,

tests/ui/lint/recursive_default_impl.rs

@@ -0,0 +1,14 @@
+//@check-fail
+
+struct Foo{
+    bar: u32,
+}
+
+impl Default for Foo {
+    fn default() -> Self {
+        Self {
+            ..Default::default()
+            //~^ ERROR: recursive default impl
+        }
+    }
+}

tests/ui/lint/recursive_default_impl.stderr

@@ -0,0 +1,21 @@
+error[E0601]: `main` function not found in crate `recursive_default_impl`
+  --> $DIR/recursive_default_impl.rs:12:2
+   |
+LL | }
+   |  ^ consider adding a `main` function to `$DIR/recursive_default_impl.rs`
+
+error: recursive default impl
+  --> $DIR/recursive_default_impl.rs:6:5
+   |
+LL |     fn default() -> Self {
+   |     ^^^^^^^^^^^^^^^^^^^^ will result in infinite recursion
+LL |         Self {
+LL |             ..Default::default()
+   |               ------------------ recursive call site
+   |
+   = help: ..default() in the Default impl does not apply a default for each struct field
+   = note: `#[deny(recursive_default_impl)]` on by default
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0601`.