Lint instead of warn

Author: iSwapna

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -1,5 +1,6 @@
 use std::iter;
 
+use rustc_hir::CRATE_HIR_ID;
 use rustc_index::IndexVec;
 use rustc_index::bit_set::BitSet;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
@@ -8,10 +9,11 @@ use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_target::abi::call::{FnAbi, PassMode};
+use rustc_session::lint;
 use tracing::{debug, instrument};
 
 use crate::traits::*;
-use crate::{base, errors};
+use crate::base;
 
 mod analyze;
 mod block;
@@ -238,12 +240,16 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
             if layout.size.bytes() >= MIN_DANGEROUS_SIZE {
                 let (size_quantity, size_unit) = human_readable_bytes(layout.size.bytes());
-                cx.tcx().dcx().emit_warn(errors::DangerousStackAllocation {
-                    span: decl.source_info.span,
-                    output: format!("{:.2} {}", size_quantity, size_unit),
-                });
+                    cx.tcx().node_span_lint(
+                        lint::builtin::DANGEROUS_STACK_ALLOCATION,
+                        CRATE_HIR_ID,
+                        decl.source_info.span,
+                        |lint| {
+                            lint.primary_message(format!("allocation of size: {:.2} {}  exceeds most system architecture limits", size_quantity, size_unit));
+                        },
+                    );
             }
-
+                        
             if local == mir::RETURN_PLACE {
                 match fx.fn_abi.ret.mode {
                     PassMode::Indirect { .. } => {

compiler/rustc_lint_defs/src/builtin.rs

@@ -31,6 +31,7 @@ declare_lint_pass! {
         CONFLICTING_REPR_HINTS,
         CONST_EVALUATABLE_UNCHECKED,
         CONST_ITEM_MUTATION,
+        DANGEROUS_STACK_ALLOCATION,
         DEAD_CODE,
         DEPENDENCY_ON_UNIT_NEVER_TYPE_FALLBACK,
         DEPRECATED,
@@ -709,6 +710,47 @@ declare_lint! {
     "detect assignments that will never be read"
 }
 
+declare_lint! {
+    /// The `dangerous_stack_allocation` lint detects stack allocations that are 1 GB or more.
+    ///
+    /// ### Example
+    ///
+    /// ``` fn func() {
+    ///     const CAP: usize = std::u32::MAX as usize;
+    ///     let mut x: [u8; CAP>>1] = [0; CAP>>1];
+    ///     x[2] = 123;
+    ///     println!("{}", x[2]);
+    /// }
+    ///
+    /// fn main() {
+    ///     std::thread::Builder::new()
+    ///         .stack_size(3 * 1024 * 1024 * 1024)
+    ///         .spawn(func)
+    ///         .unwrap()
+    ///         .join()
+    ///         .unwrap();
+    /// }
+    /// ```
+    ///
+    /// {{produces}}
+    /// ```
+    /// warning: allocation of size: 1 GiB  exceeds most system architecture limits
+    /// --> $DIR/large-stack-size-issue-83060.rs:7:9
+    /// |
+    /// LL |     let mut x: [u8; CAP>>1] = [0; CAP>>1];
+    ///  |         ^^^^^
+    ///  |
+    ///  = note: `#[warn(dangerous_stack_allocation)]` on by default
+    ///  ```
+    /// ### Explanation
+    ///
+    /// Large arras may cause stack overflow due to the limited size of the
+    /// stack on most platforms. 
+    pub DANGEROUS_STACK_ALLOCATION,
+    Warn,
+    "Detects dangerous stack allocations at the limit of most architectures"
+}
+
 declare_lint! {
     /// The `dead_code` lint detects unused, unexported items.
     ///

tests/ui/codegen/large-stack-size-issue-83060.rs renamed to tests/ui/sanitizer/large-stack-size-issue-83060.rs

@@ -5,7 +5,8 @@
 fn func() {
     const CAP: usize = std::u32::MAX as usize;
     let mut x: [u8; CAP>>1] = [0; CAP>>1];
-    //~^ warning: dangerous stack allocation of size: 1 GiB exceeds most system architecture limits
+    //~^ warning: allocation of size: 1 GiB  exceeds most system architecture limits
+    //~| NOTE on by default
     x[2] = 123;
     println!("{}", x[2]);
 }

tests/ui/codegen/large-stack-size-issue-83060.stderr renamed to tests/ui/sanitizer/large-stack-size-issue-83060.stderr

@@ -1,8 +1,10 @@
-warning: dangerous stack allocation of size: 1 GiB exceeds most system architecture limits
+warning: allocation of size: 1 GiB  exceeds most system architecture limits
   --> $DIR/large-stack-size-issue-83060.rs:7:9
    |
 LL |     let mut x: [u8; CAP>>1] = [0; CAP>>1];
    |         ^^^^^
+   |
+   = note: `#[warn(dangerous_stack_allocation)]` on by default
 
 warning: 1 warning emitted