Lint against iterator functions that panics when N is zero

Author: Urgau

compiler/rustc_mir_transform/src/errors.rs

@@ -159,6 +159,14 @@ impl AssertLintKind {
     }
 }
 
+#[derive(Diagnostic)]
+#[diag("this operation will panic at runtime")]
+pub(crate) struct ConstNIsZero {
+    #[label("const parameter `{$const_param_name}` is zero")]
+    pub const_param_span: Span,
+    pub const_param_name: Symbol,
+}
+
 #[derive(Diagnostic)]
 #[diag("call to inline assembly that may unwind")]
 pub(crate) struct AsmUnwindCall {

compiler/rustc_mir_transform/src/known_panics_lint.rs

@@ -10,19 +10,22 @@ use rustc_const_eval::interpret::{
     ImmTy, InterpCx, InterpResult, Projectable, Scalar, format_interp_error, interp_ok,
 };
 use rustc_data_structures::fx::FxHashSet;
-use rustc_hir::HirId;
 use rustc_hir::def::DefKind;
+use rustc_hir::{HirId, find_attr};
 use rustc_index::IndexVec;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::bug;
 use rustc_middle::mir::visit::{MutatingUseContext, NonMutatingUseContext, PlaceContext, Visitor};
 use rustc_middle::mir::*;
 use rustc_middle::ty::layout::{LayoutError, LayoutOf, LayoutOfHelpers, TyAndLayout};
-use rustc_middle::ty::{self, ConstInt, ScalarInt, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{
+    self, ConstInt, GenericArgKind, GenericParamDefKind, ScalarInt, Ty, TyCtxt, TypeVisitableExt,
+};
+use rustc_session::lint::builtin::UNCONDITIONAL_PANIC;
 use rustc_span::Span;
 use tracing::{debug, instrument, trace};
 
-use crate::errors::{AssertLint, AssertLintKind};
+use crate::errors::{AssertLint, AssertLintKind, ConstNIsZero};
 
 pub(super) struct KnownPanicsLint;
 
@@ -765,6 +768,38 @@ impl<'tcx> Visitor<'tcx> for ConstPropagator<'_, 'tcx> {
                 }
                 // We failed to evaluate the discriminant, fallback to visiting all successors.
             }
+            TerminatorKind::Call { func, args: _, .. } => {
+                if let Some((def_id, generic_args)) = func.const_fn_def() {
+                    for (index, arg) in generic_args.iter().enumerate() {
+                        if let GenericArgKind::Const(ct) = arg.kind() {
+                            let generics = self.tcx.generics_of(def_id);
+                            let param_def = generics.param_at(index, self.tcx);
+
+                            if let GenericParamDefKind::Const { .. } = param_def.kind
+                                && find_attr!(self.tcx, param_def.def_id, RustcPanicsWhenZero)
+                                && let Some(0) = ct.try_to_target_usize(self.tcx)
+                            {
+                                // We managed to figure-out that the value of a
+                                // `#[rustc_panics_when_zero]` const-generic parameter is zero.
+                                //
+                                // Let's report it as an unconditional panic.
+                                let source_info = self.body.source_info(location);
+                                if let Some(lint_root) = self.lint_root(*source_info) {
+                                    self.tcx.emit_node_span_lint(
+                                        UNCONDITIONAL_PANIC,
+                                        lint_root,
+                                        source_info.span,
+                                        ConstNIsZero {
+                                            const_param_span: source_info.span,
+                                            const_param_name: param_def.name,
+                                        },
+                                    );
+                                }
+                            }
+                        }
+                    }
+                }
+            }
             // None of these have Operands to const-propagate.
             TerminatorKind::Goto { .. }
             | TerminatorKind::UnwindResume
@@ -777,7 +812,6 @@ impl<'tcx> Visitor<'tcx> for ConstPropagator<'_, 'tcx> {
             | TerminatorKind::CoroutineDrop
             | TerminatorKind::FalseEdge { .. }
             | TerminatorKind::FalseUnwind { .. }
-            | TerminatorKind::Call { .. }
             | TerminatorKind::InlineAsm { .. } => {}
         }
 

tests/ui/lint/const-n-is-zero.rs

@@ -0,0 +1,55 @@
+// Test that core functions annotated with `#[rustc_panics_when_zero]` lint when `N` is zero
+
+//@ build-fail
+
+#![feature(iter_map_windows)]
+#![feature(iter_array_chunks)]
+
+const ZERO: usize = 0;
+const ONE: usize = 1;
+
+fn main() {
+    let s = [1, 2, 3, 4];
+
+    let _ = s.array_windows::<0>();
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE `#[deny(unconditional_panic)]` on by default
+    //~| NOTE const parameter `N` is zero
+
+    let _ = s.as_chunks::<{ 0 }>();
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+    //
+    let _ = s.as_rchunks::<{ 1 - 1 }>();
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    let mut m = [1, 2, 3, 4];
+
+    let _ = m.as_chunks_mut::<ZERO>();
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    let _ = m.as_rchunks_mut::<{ if ZERO == 0 { 0 } else { 1 } }>();
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    let _ = s.array_windows().any(|[]| true);
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    let _ = s.iter().map_windows(|[]| true);
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    let _ = s.iter().array_chunks().any(|[]| true);
+    //~^ ERROR this operation will panic at runtime
+    //~| NOTE const parameter `N` is zero
+
+    // Shouldn't lint
+    let _ = s.array_windows::<2>();
+    let _ = s.as_chunks::<1>();
+    let _ = m.as_chunks_mut::<ONE>();
+    let _ = m.as_rchunks::<{ 1 + 1 }>();
+    let _ = m.as_rchunks_mut::<{ if ZERO == 1 { 0 } else { 5 } }>();
+}

tests/ui/lint/const-n-is-zero.stderr

@@ -0,0 +1,52 @@
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:14:13
+   |
+LL |     let _ = s.array_windows::<0>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+   |
+   = note: `#[deny(unconditional_panic)]` on by default
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:19:13
+   |
+LL |     let _ = s.as_chunks::<{ 0 }>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:23:13
+   |
+LL |     let _ = s.as_rchunks::<{ 1 - 1 }>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:29:13
+   |
+LL |     let _ = m.as_chunks_mut::<ZERO>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:33:13
+   |
+LL |     let _ = m.as_rchunks_mut::<{ if ZERO == 0 { 0 } else { 1 } }>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:37:13
+   |
+LL |     let _ = s.array_windows().any(|[]| true);
+   |             ^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:41:13
+   |
+LL |     let _ = s.iter().map_windows(|[]| true);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: this operation will panic at runtime
+  --> $DIR/const-n-is-zero.rs:45:13
+   |
+LL |     let _ = s.iter().array_chunks().any(|[]| true);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^ const parameter `N` is zero
+
+error: aborting due to 8 previous errors
+