diff --git a/compiler/noirc_frontend/src/debug/mod.rs b/compiler/noirc_frontend/src/debug/mod.rs
index 808bbda677c..d80302401e7 100644
--- a/compiler/noirc_frontend/src/debug/mod.rs
+++ b/compiler/noirc_frontend/src/debug/mod.rs
@@ -523,7 +523,7 @@ pub fn build_debug_crate_file() -> String {
                 __debug_var_assign_oracle(var_id, value);
             }
             pub fn __debug_var_assign<T>(var_id: u32, value: T) {
-                /// Safety: debug context
+                // Safety: debug context
                 unsafe {
                 {
                     __debug_var_assign_inner(var_id, value);
@@ -536,7 +536,7 @@ pub fn build_debug_crate_file() -> String {
                 __debug_var_drop_oracle(var_id);
             }
             pub fn __debug_var_drop(var_id: u32) {
-                /// Safety: debug context
+                // Safety: debug context
                 unsafe {
                 {
                     __debug_var_drop_inner(var_id);
@@ -549,7 +549,7 @@ pub fn build_debug_crate_file() -> String {
                 __debug_fn_enter_oracle(fn_id);
             }
             pub fn __debug_fn_enter(fn_id: u32) {
-                /// Safety: debug context
+                // Safety: debug context
                 unsafe {
                 {
                     __debug_fn_enter_inner(fn_id);
@@ -562,7 +562,7 @@ pub fn build_debug_crate_file() -> String {
                 __debug_fn_exit_oracle(fn_id);
             }
             pub fn __debug_fn_exit(fn_id: u32) {
-                /// Safety: debug context
+                // Safety: debug context
                 unsafe {
                 {
                     __debug_fn_exit_inner(fn_id);
@@ -575,7 +575,7 @@ pub fn build_debug_crate_file() -> String {
                 __debug_dereference_assign_oracle(var_id, value);
             }
             pub fn __debug_dereference_assign<T>(var_id: u32, value: T) {
-                /// Safety: debug context
+                // Safety: debug context
                 unsafe {
                 {
                     __debug_dereference_assign_inner(var_id, value);
diff --git a/compiler/noirc_frontend/src/parser/errors.rs b/compiler/noirc_frontend/src/parser/errors.rs
index 508ed33857e..189b880d45e 100644
--- a/compiler/noirc_frontend/src/parser/errors.rs
+++ b/compiler/noirc_frontend/src/parser/errors.rs
@@ -110,10 +110,8 @@ pub enum ParserErrorReason {
     WrongNumberOfAttributeArguments { name: String, min: usize, max: usize, found: usize },
     #[error("The `deprecated` attribute expects a string argument")]
     DeprecatedAttributeExpectsAStringArgument,
-    #[error("Unsafe block must have a safety doc comment above it")]
+    #[error("Unsafe block must have a safety comment above it")]
     MissingSafetyComment,
-    #[error("Unsafe block must start with a safety comment")]
-    UnsafeDocCommentDoesNotStartWithSafety,
     #[error("Missing parameters for function definition")]
     MissingParametersForFunctionDefinition,
 }
@@ -285,18 +283,10 @@ impl<'a> From<&'a ParserError> for Diagnostic {
                     error.span,
                 ),
                 ParserErrorReason::MissingSafetyComment => Diagnostic::simple_warning(
-                    "Unsafe block must have a safety doc comment above it".into(),
-                    "The doc comment must start with the \"Safety: \" word".into(),
+                    "Unsafe block must have a safety comment above it".into(),
+                    "The comment must start with the \"Safety: \" word".into(),
                     error.span,
                 ),
-                ParserErrorReason::UnsafeDocCommentDoesNotStartWithSafety => {
-                    Diagnostic::simple_warning(
-                        "Unsafe block must start with a safety comment".into(),
-                        "The doc comment above this unsafe block must start with the \"Safety: \" word"
-                            .into(),
-                        error.span,
-                    )
-                }
                 ParserErrorReason::MissingParametersForFunctionDefinition => {
                     Diagnostic::simple_error(
                         "Missing parameters for function definition".into(),
@@ -304,6 +294,11 @@ impl<'a> From<&'a ParserError> for Diagnostic {
                         error.span,
                     )
                 }
+                ParserErrorReason::DocCommentDoesNotDocumentAnything => {
+                    let primary = "This doc comment doesn't document anything".to_string();
+                    let secondary = "Consider changing it to a regular `//` comment".to_string();
+                    Diagnostic::simple_warning(primary, secondary, error.span)
+                }
                 other => Diagnostic::simple_error(format!("{other}"), String::new(), error.span),
             },
             None => {
@@ -313,7 +308,7 @@ impl<'a> From<&'a ParserError> for Diagnostic {
                 ) {
                     let primary = "This doc comment doesn't document anything".to_string();
                     let secondary = "Consider changing it to a regular `//` comment".to_string();
-                    Diagnostic::simple_error(primary, secondary, error.span)
+                    Diagnostic::simple_warning(primary, secondary, error.span)
                 } else {
                     let primary = error.to_string();
                     Diagnostic::simple_error(primary, String::new(), error.span)
diff --git a/compiler/noirc_frontend/src/parser/parser.rs b/compiler/noirc_frontend/src/parser/parser.rs
index e554248fb03..f4491e84471 100644
--- a/compiler/noirc_frontend/src/parser/parser.rs
+++ b/compiler/noirc_frontend/src/parser/parser.rs
@@ -85,31 +85,25 @@ pub struct Parser<'a> {
     current_token_span: Span,
     previous_token_span: Span,
 
-    /// The current statement's doc comments.
-    /// This is used to eventually know if an `unsafe { ... }` expression is documented
+    // We also keep track of comments that appear right before a token,
+    // because `unsafe { }` requires one before it.
+    current_token_comments: String,
+    next_token_comments: String,
+
+    /// The current statement's comments.
+    /// This is used to eventually know if an `unsafe { ... }` expression is commented
     /// in its containing statement. For example:
     ///
     /// ```noir
-    /// /// Safety: test
+    /// // Safety: test
     /// let x = unsafe { call() };
     /// ```
-    statement_doc_comments: Option<StatementDocComments>,
-}
-
-#[derive(Debug)]
-pub(crate) struct StatementDocComments {
-    pub(crate) doc_comments: Vec<String>,
-    pub(crate) start_span: Span,
-    pub(crate) end_span: Span,
-
-    /// Were these doc comments "read" by an unsafe statement?
-    /// If not, these doc comments aren't documenting anything and they produce an error.
-    pub(crate) read: bool,
+    statement_comments: Option<String>,
 }
 
 impl<'a> Parser<'a> {
     pub fn for_lexer(lexer: Lexer<'a>) -> Self {
-        Self::new(TokenStream::Lexer(lexer))
+        Self::new(TokenStream::Lexer(lexer.skip_comments(false)))
     }
 
     pub fn for_tokens(mut tokens: Tokens) -> Self {
@@ -129,7 +123,9 @@ impl<'a> Parser<'a> {
             next_token: eof_spanned_token(),
             current_token_span: Default::default(),
             previous_token_span: Default::default(),
-            statement_doc_comments: None,
+            current_token_comments: String::new(),
+            next_token_comments: String::new(),
+            statement_comments: None,
         };
         parser.read_two_first_tokens();
         parser
@@ -177,25 +173,45 @@ impl<'a> Parser<'a> {
     /// Bumps this parser by one token. Returns the token that was previously the "current" token.
     fn bump(&mut self) -> SpannedToken {
         self.previous_token_span = self.current_token_span;
-        let next_next_token = self.read_token_internal();
+        let (next_next_token, next_next_token_comments) = self.read_token_internal();
         let next_token = std::mem::replace(&mut self.next_token, next_next_token);
         let token = std::mem::replace(&mut self.token, next_token);
+
+        let next_comments =
+            std::mem::replace(&mut self.next_token_comments, next_next_token_comments);
+        let _ = std::mem::replace(&mut self.current_token_comments, next_comments);
+
         self.current_token_span = self.token.to_span();
         token
     }
 
     fn read_two_first_tokens(&mut self) {
-        self.token = self.read_token_internal();
+        let (token, comments) = self.read_token_internal();
+        self.token = token;
+        self.current_token_comments = comments;
         self.current_token_span = self.token.to_span();
-        self.next_token = self.read_token_internal();
+
+        let (token, comments) = self.read_token_internal();
+        self.next_token = token;
+        self.next_token_comments = comments;
     }
 
-    fn read_token_internal(&mut self) -> SpannedToken {
+    fn read_token_internal(&mut self) -> (SpannedToken, String) {
+        let mut last_comments = String::new();
+
         loop {
             match self.tokens.next() {
-                Some(Ok(token)) => return token,
+                Some(Ok(token)) => match token.token() {
+                    Token::LineComment(comment, None) | Token::BlockComment(comment, None) => {
+                        last_comments.push_str(comment);
+                        continue;
+                    }
+                    _ => {
+                        return (token, last_comments);
+                    }
+                },
                 Some(Err(lexer_error)) => self.errors.push(lexer_error.into()),
-                None => return eof_spanned_token(),
+                None => return (eof_spanned_token(), last_comments),
             }
         }
     }
diff --git a/compiler/noirc_frontend/src/parser/parser/expression.rs b/compiler/noirc_frontend/src/parser/parser/expression.rs
index 319eefc190a..b2ddc200ef2 100644
--- a/compiler/noirc_frontend/src/parser/parser/expression.rs
+++ b/compiler/noirc_frontend/src/parser/parser/expression.rs
@@ -269,19 +269,17 @@ impl<'a> Parser<'a> {
     fn parse_atom_kind(&mut self, allow_constructors: bool) -> Option<ExpressionKind> {
         let span_before_doc_comments = self.current_token_span;
         let doc_comments = self.parse_outer_doc_comments();
-        let has_doc_comments = !doc_comments.is_empty();
-
-        if let Some(kind) = self.parse_unsafe_expr(&doc_comments, span_before_doc_comments) {
-            return Some(kind);
-        }
-
-        if has_doc_comments {
+        if !doc_comments.is_empty() {
             self.push_error(
                 ParserErrorReason::DocCommentDoesNotDocumentAnything,
-                self.span_since(span_before_doc_comments),
+                span_before_doc_comments,
             );
         }
 
+        if let Some(kind) = self.parse_unsafe_expr() {
+            return Some(kind);
+        }
+
         if let Some(literal) = self.parse_literal() {
             return Some(literal);
         }
@@ -387,41 +385,23 @@ impl<'a> Parser<'a> {
     }
 
     /// UnsafeExpression = 'unsafe' Block
-    fn parse_unsafe_expr(
-        &mut self,
-        doc_comments: &[String],
-        span_before_doc_comments: Span,
-    ) -> Option<ExpressionKind> {
+    fn parse_unsafe_expr(&mut self) -> Option<ExpressionKind> {
         let start_span = self.current_token_span;
 
         if !self.eat_keyword(Keyword::Unsafe) {
             return None;
         }
 
-        if doc_comments.is_empty() {
-            if let Some(statement_doc_comments) = &mut self.statement_doc_comments {
-                statement_doc_comments.read = true;
-
-                let doc_comments = &statement_doc_comments.doc_comments;
-                let span_before_doc_comments = statement_doc_comments.start_span;
-                let span_after_doc_comments = statement_doc_comments.end_span;
-
-                if !doc_comments[0].trim().to_lowercase().starts_with("safety:") {
-                    self.push_error(
-                        ParserErrorReason::UnsafeDocCommentDoesNotStartWithSafety,
-                        Span::from(
-                            span_before_doc_comments.start()..span_after_doc_comments.start(),
-                        ),
-                    );
+        if self.current_token_comments.is_empty() {
+            if let Some(statement_comments) = &mut self.statement_comments {
+                if !statement_comments.trim().to_lowercase().starts_with("safety:") {
+                    self.push_error(ParserErrorReason::MissingSafetyComment, start_span);
                 }
             } else {
                 self.push_error(ParserErrorReason::MissingSafetyComment, start_span);
             }
-        } else if !doc_comments[0].trim().to_lowercase().starts_with("safety:") {
-            self.push_error(
-                ParserErrorReason::UnsafeDocCommentDoesNotStartWithSafety,
-                self.span_since(span_before_doc_comments),
-            );
+        } else if !self.current_token_comments.trim().to_lowercase().starts_with("safety:") {
+            self.push_error(ParserErrorReason::MissingSafetyComment, start_span);
         }
 
         if let Some(block) = self.parse_block() {
@@ -1097,7 +1077,7 @@ mod tests {
     #[test]
     fn parses_unsafe_expression() {
         let src = "
-        /// Safety: test
+        // Safety: test
         unsafe { 1 }";
         let expr = parse_expression_no_errors(src);
         let ExpressionKind::Unsafe(block, _) = expr.kind else {
@@ -1111,7 +1091,9 @@ mod tests {
         let src = "
         /// Safety: test
         unsafe { 1 }";
-        let expr = parse_expression_no_errors(src);
+
+        let mut parser = Parser::for_str(src);
+        let expr = parser.parse_expression().unwrap();
         let ExpressionKind::Unsafe(block, _) = expr.kind else {
             panic!("Expected unsafe expression");
         };
diff --git a/compiler/noirc_frontend/src/parser/parser/item.rs b/compiler/noirc_frontend/src/parser/parser/item.rs
index 43641935565..e6ff393b498 100644
--- a/compiler/noirc_frontend/src/parser/parser/item.rs
+++ b/compiler/noirc_frontend/src/parser/parser/item.rs
@@ -276,6 +276,6 @@ mod tests {
         let (module, errors) = parse_program(&src);
         assert_eq!(module.items.len(), 1);
         let error = get_single_error(&errors, span);
-        assert!(error.to_string().contains("Documentation comment does not document anything"));
+        assert!(error.to_string().contains("This doc comment doesn't document anything"));
     }
 }
diff --git a/compiler/noirc_frontend/src/parser/parser/statement.rs b/compiler/noirc_frontend/src/parser/parser/statement.rs
index f9cc63a364e..59bcc896033 100644
--- a/compiler/noirc_frontend/src/parser/parser/statement.rs
+++ b/compiler/noirc_frontend/src/parser/parser/statement.rs
@@ -10,7 +10,7 @@ use crate::{
     token::{Attribute, Keyword, Token, TokenKind},
 };
 
-use super::{Parser, StatementDocComments};
+use super::Parser;
 
 impl<'a> Parser<'a> {
     pub(crate) fn parse_statement_or_error(&mut self) -> Statement {
@@ -27,35 +27,24 @@ impl<'a> Parser<'a> {
         loop {
             let span_before_doc_comments = self.current_token_span;
             let doc_comments = self.parse_outer_doc_comments();
-            let span_after_doc_comments = self.current_token_span;
-            if doc_comments.is_empty() {
-                self.statement_doc_comments = None;
+            if !doc_comments.is_empty() {
+                self.push_error(
+                    ParserErrorReason::DocCommentDoesNotDocumentAnything,
+                    span_before_doc_comments,
+                );
+            }
+
+            if !self.current_token_comments.is_empty() {
+                self.statement_comments = Some(std::mem::take(&mut self.current_token_comments));
             } else {
-                self.statement_doc_comments = Some(StatementDocComments {
-                    doc_comments,
-                    start_span: span_before_doc_comments,
-                    end_span: span_after_doc_comments,
-                    read: false,
-                });
+                self.statement_comments = None;
             }
 
             let attributes = self.parse_attributes();
             let start_span = self.current_token_span;
             let kind = self.parse_statement_kind(attributes);
 
-            if let Some(statement_doc_comments) = &self.statement_doc_comments {
-                if !statement_doc_comments.read {
-                    self.push_error(
-                        ParserErrorReason::DocCommentDoesNotDocumentAnything,
-                        Span::from(
-                            statement_doc_comments.start_span.start()
-                                ..statement_doc_comments.end_span.start(),
-                        ),
-                    );
-                }
-            }
-
-            self.statement_doc_comments = None;
+            self.statement_comments = None;
 
             let (semicolon_token, semicolon_span) = if self.at(Token::Semicolon) {
                 let token = self.token.clone();
@@ -491,7 +480,7 @@ mod tests {
 
     #[test]
     fn parses_let_statement_with_unsafe() {
-        let src = "/// Safety: doc comment
+        let src = "// Safety: comment
         let x = unsafe { 1 };";
         let statement = parse_statement_no_errors(src);
         let StatementKind::Let(let_statement) = statement.kind else {
@@ -500,6 +489,18 @@ mod tests {
         assert_eq!(let_statement.pattern.to_string(), "x");
     }
 
+    #[test]
+    fn parses_let_statement_with_unsafe_doc_comment() {
+        let src = "/// Safety: doc comment
+        let x = unsafe { 1 };";
+        let mut parser = Parser::for_str(src);
+        let (statement, _) = parser.parse_statement().unwrap();
+        let StatementKind::Let(let_statement) = statement.kind else {
+            panic!("Expected let statement");
+        };
+        assert_eq!(let_statement.pattern.to_string(), "x");
+    }
+
     #[test]
     fn parses_comptime_block() {
         let src = "comptime { 1 }";
@@ -613,7 +614,7 @@ mod tests {
 
     #[test]
     fn parses_assignment_with_unsafe() {
-        let src = "/// Safety: test 
+        let src = "// Safety: test 
         x = unsafe { 1 }";
         let statement = parse_statement_no_errors(src);
         let StatementKind::Assign(assign) = statement.kind else {
@@ -647,7 +648,7 @@ mod tests {
 
     #[test]
     fn parses_op_assignment_with_unsafe() {
-        let src = "/// Safety: comment
+        let src = "// Safety: comment
         x += unsafe { 1 }";
         let statement = parse_statement_no_errors(src);
         let StatementKind::Assign(_) = statement.kind else {
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index 40e9f778f07..af1948f012e 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -3904,7 +3904,7 @@ fn errors_on_cyclic_globals() {
 fn warns_on_unneeded_unsafe() {
     let src = r#"
     fn main() {
-        /// Safety: test
+        // Safety: test
         unsafe {
             foo()
         }
@@ -3924,9 +3924,9 @@ fn warns_on_unneeded_unsafe() {
 fn warns_on_nested_unsafe() {
     let src = r#"
     fn main() {
-        /// Safety: test
+        // Safety: test
         unsafe {
-            /// Safety: test
+            // Safety: test
             unsafe {
                 foo()
             }
@@ -4253,7 +4253,7 @@ fn error_with_duplicate_enum_variant() {
 fn errors_on_empty_loop_no_break() {
     let src = r#"
     fn main() {
-        /// Safety: test
+        // Safety: test
         unsafe {
             foo()
         }
@@ -4275,7 +4275,7 @@ fn errors_on_empty_loop_no_break() {
 fn errors_on_loop_without_break() {
     let src = r#"
     fn main() {
-        /// Safety: test
+        // Safety: test
         unsafe {
             foo()
         }
@@ -4303,7 +4303,7 @@ fn errors_on_loop_without_break() {
 fn errors_on_loop_without_break_with_nested_loop() {
     let src = r#"
     fn main() {
-        /// Safety: test
+        // Safety: test
         unsafe {
             foo()
         }
diff --git a/compiler/noirc_frontend/src/tests/references.rs b/compiler/noirc_frontend/src/tests/references.rs
index 956b2c5f05e..5dbc395eb59 100644
--- a/compiler/noirc_frontend/src/tests/references.rs
+++ b/compiler/noirc_frontend/src/tests/references.rs
@@ -87,7 +87,7 @@ fn constrained_reference_to_unconstrained() {
     fn main(mut x: u32, y: pub u32) {
         let x_ref = &mut x;
         if x == 5  {
-            /// Safety: test context
+            // Safety: test context
             unsafe {
                 mut_ref_input(x_ref, y);        
             }
diff --git a/docs/docs/noir/concepts/unconstrained.md b/docs/docs/noir/concepts/unconstrained.md
index 26a5df0be3e..467253bed0d 100644
--- a/docs/docs/noir/concepts/unconstrained.md
+++ b/docs/docs/noir/concepts/unconstrained.md
@@ -66,7 +66,7 @@ We can then run `u72_to_u8` as unconstrained brillig code in order to calculate
 
 ```rust
 fn main(num: u72) -> pub [u8; 8] {
-    /// Safety: 'out' is properly constrained below in 'assert(num == reconstructed_num);'
+    // Safety: 'out' is properly constrained below in 'assert(num == reconstructed_num);'
     let out = unsafe { u72_to_u8(num) };
 
     let mut reconstructed_num: u72 = 0;
@@ -95,7 +95,7 @@ This ends up taking off another ~250 gates from our circuit! We've ended up with
 
 Note that in order to invoke unconstrained functions we need to wrap them in an `unsafe` block,
 to make it clear that the call is unconstrained.
-Furthermore, a warning is emitted unless the `unsafe` block is documented with a `/// Safety: ...` doc comment explaining why it is fine to call the unconstrained function. Note that either the `unsafe` block can be documented this way or the statement it exists in (like in the `let` example above).
+Furthermore, a warning is emitted unless the `unsafe` block is commented with a `// Safety: ...` comment explaining why it is fine to call the unconstrained function. Note that either the `unsafe` block can be commented this way or the statement it exists in (like in the `let` example above).
 
 Generally we want to use brillig whenever there's something that's easy to verify but hard to compute within the circuit. For example, if you wanted to calculate a square root of a number it'll be a much better idea to calculate this in brillig and then assert that if you square the result you get back your number.
 
diff --git a/noir_stdlib/src/array/check_shuffle.nr b/noir_stdlib/src/array/check_shuffle.nr
index 327f0559810..70c54a6d842 100644
--- a/noir_stdlib/src/array/check_shuffle.nr
+++ b/noir_stdlib/src/array/check_shuffle.nr
@@ -42,8 +42,8 @@ pub(crate) fn check_shuffle<T, let N: u32>(lhs: [T; N], rhs: [T; N])
 where
     T: Eq,
 {
-    /// Safety: shuffle_indices is ensured to be a permutation of 0..N, and then
-    /// shuffle_indices is ensured to map lhs to rhs: assert(lhs[i] == rhs[shuffle_indices[i]]), for all i in 0..N
+    // Safety: shuffle_indices is ensured to be a permutation of 0..N, and then
+    // shuffle_indices is ensured to map lhs to rhs: assert(lhs[i] == rhs[shuffle_indices[i]]), for all i in 0..N
     unsafe {
         let shuffle_indices = __get_shuffle_indices(lhs, rhs);
 
diff --git a/noir_stdlib/src/array/mod.nr b/noir_stdlib/src/array/mod.nr
index 85cc0580aae..bca59d5ade0 100644
--- a/noir_stdlib/src/array/mod.nr
+++ b/noir_stdlib/src/array/mod.nr
@@ -184,9 +184,9 @@ where
     /// }
     /// ```
     pub fn sort_via<Env>(self, ordering: fn[Env](T, T) -> bool) -> Self {
-        /// Safety: `sorted` array is checked to be:
-        /// a. a permutation of `input`'s elements
-        /// b. satisfying the predicate `ordering`
+        // Safety: `sorted` array is checked to be:
+        // a. a permutation of `input`'s elements
+        // b. satisfying the predicate `ordering`
         unsafe {
             let sorted = quicksort::quicksort(self, ordering);
 
diff --git a/noir_stdlib/src/collections/umap.nr b/noir_stdlib/src/collections/umap.nr
index bcb9759b4db..fa7fb774ce3 100644
--- a/noir_stdlib/src/collections/umap.nr
+++ b/noir_stdlib/src/collections/umap.nr
@@ -113,7 +113,7 @@ impl<K, V, B> UHashMap<K, V, B> {
         H: Hasher,
     {
         // docs:end:contains_key
-        /// Safety: unconstrained context
+        // Safety: unconstrained context
         unsafe { self.get(key) }.is_some()
     }
 
@@ -433,7 +433,7 @@ where
                 // Not marked as deleted and has key-value.
                 if equal & slot.is_valid() {
                     let (key, value) = slot.key_value_unchecked();
-                    /// Safety: unconstrained context
+                    // Safety: unconstrained context
                     let other_value = unsafe { other.get(key) };
 
                     if other_value.is_none() {
diff --git a/noir_stdlib/src/field/bn254.nr b/noir_stdlib/src/field/bn254.nr
index a298a5d1e38..90a439d2010 100644
--- a/noir_stdlib/src/field/bn254.nr
+++ b/noir_stdlib/src/field/bn254.nr
@@ -38,9 +38,9 @@ unconstrained fn lte_hint(x: Field, y: Field) -> bool {
 fn assert_gt_limbs(a: (Field, Field), b: (Field, Field)) {
     let (alo, ahi) = a;
     let (blo, bhi) = b;
-    /// Safety: borrow is enforced to be boolean due to its type.
-    /// if borrow is 0, it asserts that (alo > blo && ahi >= bhi)
-    /// if borrow is 1, it asserts that (alo <= blo && ahi > bhi)
+    // Safety: borrow is enforced to be boolean due to its type.
+    // if borrow is 0, it asserts that (alo > blo && ahi >= bhi)
+    // if borrow is 1, it asserts that (alo <= blo && ahi > bhi)
     unsafe {
         let borrow = lte_hint(alo, blo);
 
@@ -57,7 +57,7 @@ pub fn decompose(x: Field) -> (Field, Field) {
     if is_unconstrained() {
         compute_decomposition(x)
     } else {
-        /// Safety: decomposition is properly checked below
+        // Safety: decomposition is properly checked below
         unsafe {
             // Take hints of the decomposition
             let (xlo, xhi) = decompose_hint(x);
@@ -79,7 +79,7 @@ pub fn decompose(x: Field) -> (Field, Field) {
 pub fn assert_gt(a: Field, b: Field) {
     if is_unconstrained() {
         assert(
-            /// Safety: already unconstrained
+            // Safety: already unconstrained
             unsafe { field_less_than(b, a) },
         );
     } else {
@@ -98,14 +98,14 @@ pub fn assert_lt(a: Field, b: Field) {
 
 pub fn gt(a: Field, b: Field) -> bool {
     if is_unconstrained() {
-        /// Safety: unsafe in unconstrained
+        // Safety: unsafe in unconstrained
         unsafe {
             field_less_than(b, a)
         }
     } else if a == b {
         false
     } else {
-        /// Safety: Take a hint of the comparison and verify it
+        // Safety: Take a hint of the comparison and verify it
         unsafe {
             if field_less_than(a, b) {
                 assert_gt(b, a);
diff --git a/noir_stdlib/src/field/mod.nr b/noir_stdlib/src/field/mod.nr
index 3dad654dfc7..b1e9ec1edf9 100644
--- a/noir_stdlib/src/field/mod.nr
+++ b/noir_stdlib/src/field/mod.nr
@@ -315,7 +315,7 @@ pub fn bytes32_to_field(bytes32: [u8; 32]) -> Field {
 
 fn lt_fallback(x: Field, y: Field) -> bool {
     if is_unconstrained() {
-        /// Safety: unconstrained context
+        // Safety: unconstrained context
         unsafe {
             field_less_than(x, y)
         }
diff --git a/noir_stdlib/src/hash/mod.nr b/noir_stdlib/src/hash/mod.nr
index 104368b50fa..ee78d04c91b 100644
--- a/noir_stdlib/src/hash/mod.nr
+++ b/noir_stdlib/src/hash/mod.nr
@@ -96,7 +96,7 @@ fn __derive_generators<let N: u32, let M: u32>(
 // does not assert the limbs are 128 bits
 // does not assert the decomposition does not overflow the EmbeddedCurveScalar
 fn from_field_unsafe(scalar: Field) -> EmbeddedCurveScalar {
-    /// Safety: xlo and xhi decomposition is checked below
+    // Safety: xlo and xhi decomposition is checked below
     let (xlo, xhi) = unsafe { crate::field::bn254::decompose_hint(scalar) };
     // Check that the decomposition is correct
     assert_eq(scalar, xlo + crate::field::bn254::TWO_POW_128 * xhi);
diff --git a/noir_stdlib/src/hash/sha256.nr b/noir_stdlib/src/hash/sha256.nr
index 1bbeada3431..a8bd71a2111 100644
--- a/noir_stdlib/src/hash/sha256.nr
+++ b/noir_stdlib/src/hash/sha256.nr
@@ -76,7 +76,7 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {
     let mut msg_byte_ptr = 0;
     for i in 0..num_blocks {
         let msg_start = BLOCK_SIZE * i;
-        /// Safety: the msg_block is checked below in verify_msg_block
+        // Safety: the msg_block is checked below in verify_msg_block
         let (new_msg_block, new_msg_byte_ptr) =
             unsafe { build_msg_block(msg, message_size, msg_start) };
 
@@ -107,7 +107,7 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {
     // or our message cannot be evenly split into blocks.
     if modulo != 0 {
         let msg_start = BLOCK_SIZE * num_blocks;
-        /// Safety: the msg_block is checked below in verify_msg_block
+        // Safety: the msg_block is checked below in verify_msg_block
         let (new_msg_block, new_msg_byte_ptr) =
             unsafe { build_msg_block(msg, message_size, msg_start) };
 
@@ -150,7 +150,7 @@ pub fn sha256_var<let N: u32>(msg: [u8; N], message_size: u64) -> HASH {
         msg_byte_ptr = 0;
     }
 
-    /// Safety: the msg_len is checked below in verify_msg_len
+    // Safety: the msg_len is checked below in verify_msg_len
     msg_block = unsafe { attach_len_to_msg_block(msg_block, msg_byte_ptr, message_size) };
 
     if !is_unconstrained() {
@@ -804,7 +804,7 @@ mod tests {
         ];
         assert_eq(input.len(), 22);
 
-        /// Safety: testing context
+        // Safety: testing context
         let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 0) };
         assert_eq(msg_byte_ptr, input.len());
         assert_eq(msg_block[0], make_item(input[0], input[1], input[2], input[3]));
@@ -822,7 +822,7 @@ mod tests {
             108, 97, 105, 110, 59, 32, 99, 104, 97, 114, 115, 101, 116,
         ];
         assert_eq(input.len(), 68);
-        /// Safety: test context
+        // Safety: test context
         let (msg_block, msg_byte_ptr) = unsafe { build_msg_block(input, input.len(), 64) };
         assert_eq(msg_byte_ptr, 4);
         assert_eq(msg_block[0], make_item(input[64], input[65], input[66], input[67]));
@@ -836,7 +836,7 @@ mod tests {
             1919905082, 1131376244, 1701737517, 1417244773, 978151789, 1697470053, 1920166255,
             1849316213, 1651139939,
         ];
-        /// Safety: testing context
+        // Safety: testing context
         let msg_block = unsafe { attach_len_to_msg_block(input, 1, 448) };
         assert_eq(msg_block[0], ((1 << 7) as u32) * 256 * 256 * 256);
         assert_eq(msg_block[1], 0);
diff --git a/noir_stdlib/src/lib.nr b/noir_stdlib/src/lib.nr
index fb073516d29..4074e5e6920 100644
--- a/noir_stdlib/src/lib.nr
+++ b/noir_stdlib/src/lib.nr
@@ -40,14 +40,14 @@ unconstrained fn print_unconstrained<T>(with_newline: bool, input: T) {
 }
 
 pub fn println<T>(input: T) {
-    /// Safety: a print statement cannot be constrained
+    // Safety: a print statement cannot be constrained
     unsafe {
         print_unconstrained(true, input);
     }
 }
 
 pub fn print<T>(input: T) {
-    /// Safety: a print statement cannot be constrained
+    // Safety: a print statement cannot be constrained
     unsafe {
         print_unconstrained(false, input);
     }
diff --git a/noir_stdlib/src/meta/expr.nr b/noir_stdlib/src/meta/expr.nr
index a1663135c20..b71a3b17429 100644
--- a/noir_stdlib/src/meta/expr.nr
+++ b/noir_stdlib/src/meta/expr.nr
@@ -643,7 +643,7 @@ comptime fn new_unary_op(op: UnaryOp, rhs: Expr) -> Expr {
 comptime fn new_unsafe(exprs: [Expr]) -> Expr {
     let exprs = join_expressions(exprs, quote { ; });
     quote { 
-        /// Safety: generated by macro
+        // Safety: generated by macro
         unsafe { $exprs }
     }
         .as_expr()
diff --git a/noir_stdlib/src/uint128.nr b/noir_stdlib/src/uint128.nr
index c053c0b339a..f41958e0e30 100644
--- a/noir_stdlib/src/uint128.nr
+++ b/noir_stdlib/src/uint128.nr
@@ -104,7 +104,7 @@ impl U128 {
             if ascii < 58 {
                 ascii - 48
             } else {
-                /// Safety: optionally adds 32 and then check (below) the result is in 'a..f' range
+                // Safety: optionally adds 32 and then check (below) the result is in 'a..f' range
                 let ascii =
                     ascii + 32 * (unsafe { U128::unconstrained_check_is_upper_ascii(ascii) as u8 });
                 assert(ascii >= 97); // enforce >= 'a'
@@ -213,8 +213,8 @@ impl Mul for U128 {
 
 impl Div for U128 {
     fn div(self: Self, b: U128) -> U128 {
-        /// Safety: euclidian division is asserted to be correct: assert(a == b * q + r); and assert(r < b);
-        /// Furthermore, U128 addition and multiplication ensures that b * q + r does not overflow
+        // Safety: euclidian division is asserted to be correct: assert(a == b * q + r); and assert(r < b);
+        // Furthermore, U128 addition and multiplication ensures that b * q + r does not overflow
         unsafe {
             let (q, r) = self.unconstrained_div(b);
             let a = b * q + r;
@@ -227,7 +227,7 @@ impl Div for U128 {
 
 impl Rem for U128 {
     fn rem(self: Self, b: U128) -> U128 {
-        /// Safety: cf div() above
+        // Safety: cf div() above
         unsafe {
             let (q, r) = self.unconstrained_div(b);
             let a = b * q + r;
@@ -455,7 +455,7 @@ mod tests {
         let b = U128::from_u64s_le(0x0, 0xfffffffffffffffe);
         let c = U128::one();
         let d = U128::from_u64s_le(0x0, 0x1);
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             let (q, r) = a.unconstrained_div(b);
             assert_eq(q, c);
@@ -465,14 +465,14 @@ mod tests {
         let a = U128::from_u64s_le(2, 0);
         let b = U128::one();
         // Check the case where a is a multiple of b
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             let (c, d) = a.unconstrained_div(b);
             assert_eq((c, d), (a, U128::zero()));
         }
 
         // Check where b is a multiple of a
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             let (c, d) = b.unconstrained_div(a);
             assert_eq((c, d), (U128::zero(), b));
@@ -481,7 +481,7 @@ mod tests {
         // Dividing by zero returns 0,0
         let a = U128::from_u64s_le(0x1, 0x0);
         let b = U128::zero();
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             let (c, d) = a.unconstrained_div(b);
             assert_eq((c, d), (U128::zero(), U128::zero()));
@@ -489,7 +489,7 @@ mod tests {
         // Dividing 1<<127 by 1<<127 (special case)
         let a = U128::from_u64s_le(0x0, pow63 as u64);
         let b = U128::from_u64s_le(0x0, pow63 as u64);
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             let (c, d) = a.unconstrained_div(b);
             assert_eq((c, d), (U128::one(), U128::zero()));
diff --git a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
index d4450ec62b1..6c545d60ea3 100644
--- a/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
+++ b/test_programs/compile_failure/brillig_mut_ref_from_acir/src/main.nr
@@ -3,7 +3,7 @@ unconstrained fn mut_ref_identity(value: &mut Field) -> Field {
 }
 
 fn main(mut x: Field, y: pub Field) {
-    /// Safety: testing context
+    // Safety: testing context
     let returned_x = unsafe { mut_ref_identity(&mut x) };
     assert(returned_x == x);
 }
diff --git a/test_programs/compile_failure/regression_5008/src/main.nr b/test_programs/compile_failure/regression_5008/src/main.nr
index 5155900734c..54c6333b1bd 100644
--- a/test_programs/compile_failure/regression_5008/src/main.nr
+++ b/test_programs/compile_failure/regression_5008/src/main.nr
@@ -13,6 +13,6 @@ impl Foo {
 fn main() {
     let foo = Foo { bar: &mut Bar { value: 0 } };
 
-    /// Safety: testing context
+    // Safety: testing context
     unsafe { foo.crash_fn() };
 }
diff --git a/test_programs/compile_failure/unconstrained_ref/src/main.nr b/test_programs/compile_failure/unconstrained_ref/src/main.nr
index 23dc1d66673..db6f74d3c51 100644
--- a/test_programs/compile_failure/unconstrained_ref/src/main.nr
+++ b/test_programs/compile_failure/unconstrained_ref/src/main.nr
@@ -4,6 +4,6 @@ unconstrained fn uncon_ref() -> &mut Field {
 }
 
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     let e = unsafe { uncon_ref() };
 }
diff --git a/test_programs/compile_success_empty/acir_inside_brillig_recursion/src/main.nr b/test_programs/compile_success_empty/acir_inside_brillig_recursion/src/main.nr
index 12c663b2705..c0e8a9942d5 100644
--- a/test_programs/compile_success_empty/acir_inside_brillig_recursion/src/main.nr
+++ b/test_programs/compile_success_empty/acir_inside_brillig_recursion/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert_eq(fibonacci(3), fibonacci_hint(3));
     }
diff --git a/test_programs/compile_success_empty/brillig_cast/src/main.nr b/test_programs/compile_success_empty/brillig_cast/src/main.nr
index d7d0b1b8fa5..7b523827398 100644
--- a/test_programs/compile_success_empty/brillig_cast/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_cast/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested are cast operations on brillig
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         bool_casts();
         field_casts();
diff --git a/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
index f55beb6d1a8..aad22aaf38f 100644
--- a/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_field_binary_operations/src/main.nr
@@ -1,6 +1,6 @@
 // Tests arithmetic operations on fields
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let x = 4;
         let y = 2;
diff --git a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
index 0e00f25e5bb..032fbf457b6 100644
--- a/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_integer_binary_operations/src/main.nr
@@ -3,7 +3,7 @@ fn main() {
     let x: u32 = 6;
     let y: u32 = 2;
 
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert((x + y) == add(x, y));
 
diff --git a/test_programs/compile_success_empty/brillig_modulo/src/main.nr b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
index 841d7d2dfca..b60d781e0c8 100644
--- a/test_programs/compile_success_empty/brillig_modulo/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_modulo/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is modulo operations on brillig
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(modulo(47, 3) == 2);
         assert(modulo(2, 3) == 2);
diff --git a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
index c43c5fae162..2aace852db9 100644
--- a/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
+++ b/test_programs/compile_success_empty/brillig_slice_input/src/main.nr
@@ -16,14 +16,14 @@ unconstrained fn sum_slice(slice: [[Point; 2]]) -> Field {
 fn main() {
     let mut slice = &[];
     slice = slice.push_back([Point { x: 13, y: 14 }, Point { x: 20, y: 8 }]);
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let brillig_sum = sum_slice(slice);
         assert_eq(brillig_sum, 55);
     }
 
     slice = slice.push_back([Point { x: 15, y: 5 }, Point { x: 12, y: 13 }]);
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let brillig_sum = sum_slice(slice);
         assert_eq(brillig_sum, 100);
diff --git a/test_programs/compile_success_empty/comptime_function_definition/src/main.nr b/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
index f912ecb7bfc..57bcd2ba90e 100644
--- a/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
+++ b/test_programs/compile_success_empty/comptime_function_definition/src/main.nr
@@ -142,7 +142,7 @@ mod test_as_typed_expr_2 {
         let func = method.as_typed_expr();
         quote { 
             pub fn bar() -> u32 {
-                /// Safety: test program
+                // Safety: test program
                 unsafe { $func([1, 2, 3, 0]) }
             }
         }
@@ -168,7 +168,7 @@ mod test_as_typed_expr_3 {
         let func = method.as_typed_expr();
         quote { 
             pub fn bar() -> u32 {
-                /// Safety: test program
+                // Safety: test program
                 comptime { $func(([1, 2, 3, 0], "a")) }
             }
         }
diff --git a/test_programs/compile_success_empty/is_unconstrained/src/main.nr b/test_programs/compile_success_empty/is_unconstrained/src/main.nr
index 856040b2274..34e29bb948b 100644
--- a/test_programs/compile_success_empty/is_unconstrained/src/main.nr
+++ b/test_programs/compile_success_empty/is_unconstrained/src/main.nr
@@ -9,7 +9,7 @@ unconstrained fn unconstrained_intermediate() {
 }
 
 fn main() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         unconstrained_intermediate();
     }
diff --git a/test_programs/compile_success_no_bug/check_unconstrained_regression/src/main.nr b/test_programs/compile_success_no_bug/check_unconstrained_regression/src/main.nr
index e4cb15f099d..096d2fee24b 100644
--- a/test_programs/compile_success_no_bug/check_unconstrained_regression/src/main.nr
+++ b/test_programs/compile_success_no_bug/check_unconstrained_regression/src/main.nr
@@ -19,7 +19,7 @@ unconstrained fn convert(trigger: Trigger) -> ResultType {
 }
 impl Trigger {
     fn execute(self) -> ResultType {
-        /// Safety: testing context
+        // Safety: testing context
         let result = unsafe { convert(self) };
         assert(result.a == self.x + 1);
         assert(result.b == self.y - 1 + self.z[2]);
diff --git a/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr b/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
index 9b6ad264a9e..b2c8ceacdf7 100644
--- a/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
+++ b/test_programs/compile_success_no_bug/databus_mapping_regression/src/main.nr
@@ -8,11 +8,17 @@ impl Empty for Field {
     }
 }
 
-pub fn is_empty<T>(item: T) -> bool where T: Empty + Eq {
+pub fn is_empty<T>(item: T) -> bool
+where
+    T: Empty + Eq,
+{
     item.eq(T::empty())
 }
 
-pub fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N> where T: Empty + Eq {
+pub fn array_to_bounded_vec<T, let N: u32>(array: [T; N]) -> BoundedVec<T, N>
+where
+    T: Empty + Eq,
+{
     let mut len = 0;
     for elem in array {
         if !is_empty(elem) {
@@ -28,7 +34,7 @@ global APP_CALL_SIZE: u32 = 2;
 
 fn main(
     a: call_data(0) [Field; TX_SIZE],
-    b: call_data(1) [Field; APP_CALL_SIZE]
+    b: call_data(1) [Field; APP_CALL_SIZE],
 ) -> return_data [Field; TX_SIZE] {
     let mut a_as_bounded_vec = array_to_bounded_vec(a);
 
diff --git a/test_programs/compile_success_no_bug/regression_7062/src/main.nr b/test_programs/compile_success_no_bug/regression_7062/src/main.nr
index c640062b45b..f992a596fd7 100644
--- a/test_programs/compile_success_no_bug/regression_7062/src/main.nr
+++ b/test_programs/compile_success_no_bug/regression_7062/src/main.nr
@@ -1,8 +1,8 @@
 fn main(args: [Field; 2]) {
-    /// Safety: n/a
+    // Safety: n/a
     unsafe { store(args) };
     // Dummy test to remove the 'underconstraint bug'
     assert(args[0] + args[1] != 0);
 }
 
-pub unconstrained fn store(_: [Field]) {}
\ No newline at end of file
+pub unconstrained fn store(_: [Field]) {}
diff --git a/test_programs/compile_success_no_bug/regression_7292/src/main.nr b/test_programs/compile_success_no_bug/regression_7292/src/main.nr
index 395cd82e1ca..dde1b2c89a3 100644
--- a/test_programs/compile_success_no_bug/regression_7292/src/main.nr
+++ b/test_programs/compile_success_no_bug/regression_7292/src/main.nr
@@ -3,7 +3,7 @@ unconstrained fn foo<T>(_x: T) -> Field {
 }
 
 fn main() {
-    /// Safety: test
+    // Safety: test
     unsafe {
         assert(foo(0) == 0);
     }
diff --git a/test_programs/compile_success_with_bug/regression_7103/src/main.nr b/test_programs/compile_success_with_bug/regression_7103/src/main.nr
index 7ce01c2b079..74a6fc8148c 100644
--- a/test_programs/compile_success_with_bug/regression_7103/src/main.nr
+++ b/test_programs/compile_success_with_bug/regression_7103/src/main.nr
@@ -1,9 +1,8 @@
 fn main() {
-    /// Safety: n/a
+    // Safety: n/a
     unsafe { loophole() };
 }
 
-
 unconstrained fn loophole() {
     let mut i = 0;
     loop {
@@ -13,4 +12,4 @@ unconstrained fn loophole() {
             break;
         }
     }
-}
\ No newline at end of file
+}
diff --git a/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr
index 22e2bc0b49d..84215e50901 100644
--- a/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr
+++ b/test_programs/compile_success_with_bug/underconstrained_value_detector_5425/src/main.nr
@@ -9,7 +9,7 @@ unconstrained fn maximum_price(options: [u32; 3]) -> u32 {
 }
 
 fn main(sandwiches: pub [u32; 3], drinks: pub [u32; 3], snacks: pub [u32; 3], best_value: u32) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let meal_deal_cost: u32 = 390;
         let most_expensive_sandwich = maximum_price(sandwiches);
diff --git a/test_programs/execution_failure/brillig_assert_fail/src/main.nr b/test_programs/execution_failure/brillig_assert_fail/src/main.nr
index 18e6422361c..9aaf026a550 100644
--- a/test_programs/execution_failure/brillig_assert_fail/src/main.nr
+++ b/test_programs/execution_failure/brillig_assert_fail/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is using assert on brillig
 fn main(x: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     assert(1 == unsafe { conditional(x as bool) });
 }
 
diff --git a/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr b/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
index 9c07660217b..82d58a0b70c 100644
--- a/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
+++ b/test_programs/execution_failure/brillig_assert_msg_runtime/src/main.nr
@@ -1,5 +1,5 @@
 fn main(x: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     assert(1 == unsafe { conditional(x) });
 }
 
diff --git a/test_programs/execution_failure/regression_5202/src/main.nr b/test_programs/execution_failure/regression_5202/src/main.nr
index 0c3a9693958..3b6972165fa 100644
--- a/test_programs/execution_failure/regression_5202/src/main.nr
+++ b/test_programs/execution_failure/regression_5202/src/main.nr
@@ -17,12 +17,12 @@ unconstrained fn should_i_assert() -> bool {
 }
 
 fn get_magical_boolean() -> bool {
-    /// Safety: testing context
+    // Safety: testing context
     let option = unsafe { get_unconstrained_option() };
 
     let pre_assert = option.is_some().to_field();
 
-    /// Safety: testing context
+    // Safety: testing context
     if unsafe { should_i_assert() } {
         // Note that `should_i_assert` is unconstrained, so Noir should not be able to infer
         // any behavior from the contents of this block. In this case it is actually false, so the
diff --git a/test_programs/execution_success/aes128_encrypt/src/main.nr b/test_programs/execution_success/aes128_encrypt/src/main.nr
index 11f9512444e..dbb7fc4d7b8 100644
--- a/test_programs/execution_success/aes128_encrypt/src/main.nr
+++ b/test_programs/execution_success/aes128_encrypt/src/main.nr
@@ -29,11 +29,11 @@ fn main(inputs: str<12>, iv: str<16>, key: str<16>, output: str<32>) {
     let result: [u8; 16] =
         std::aes128::aes128_encrypt(inputs.as_bytes(), iv.as_bytes(), key.as_bytes());
 
-    /// Safety: testing context
+    // Safety: testing context
     let output_bytes: [u8; 16] = unsafe { decode_hex(output) };
     assert(result == output_bytes);
 
-    /// Safety: testing context
+    // Safety: testing context
     let unconstrained_result = unsafe { cipher(inputs.as_bytes(), iv.as_bytes(), key.as_bytes()) };
     assert(unconstrained_result == output_bytes);
 }
diff --git a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
index 1d29db4973a..132d0a19248 100644
--- a/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
+++ b/test_programs/execution_success/array_to_slice_constant_length/src/main.nr
@@ -4,7 +4,7 @@ unconstrained fn return_array(val: Field) -> [Field; 1] {
 }
 
 fn main(val: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let array = return_array(val);
         assert_constant(array.as_slice().len());
diff --git a/test_programs/execution_success/bigint/src/main.nr b/test_programs/execution_success/bigint/src/main.nr
index 2095c92349a..2ccb446b8b4 100644
--- a/test_programs/execution_success/bigint/src/main.nr
+++ b/test_programs/execution_success/bigint/src/main.nr
@@ -17,7 +17,7 @@ fn main(mut x: [u8; 5], y: [u8; 5]) {
     let c = if x[0] != 0 {
         test_unconstrained1(a, b)
     } else {
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             test_unconstrained2(a, b)
         }
diff --git a/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr b/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
index a327dfd7533..c7e68f0edd6 100644
--- a/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
+++ b/test_programs/execution_success/brillig_acir_as_brillig/src/main.nr
@@ -1,5 +1,5 @@
 fn main(x: u32) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(entry_point(x) == 2);
         swap_entry_point(x, x + 1);
diff --git a/test_programs/execution_success/brillig_arrays/src/main.nr b/test_programs/execution_success/brillig_arrays/src/main.nr
index f0524842ac6..5de6e08ac15 100644
--- a/test_programs/execution_success/brillig_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_arrays/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested are array reads and writes
 fn main(x: [Field; 3]) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         read_array(x);
         read_write_array(x);
diff --git a/test_programs/execution_success/brillig_blake2s/src/main.nr b/test_programs/execution_success/brillig_blake2s/src/main.nr
index 7e567b84139..2dbbca771ed 100644
--- a/test_programs/execution_success/brillig_blake2s/src/main.nr
+++ b/test_programs/execution_success/brillig_blake2s/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is blake2s in brillig
 fn main(x: [u8; 5], result: [u8; 32]) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(blake2s(x) == result);
     }
diff --git a/test_programs/execution_success/brillig_calls_array/src/main.nr b/test_programs/execution_success/brillig_calls_array/src/main.nr
index b27eb30da17..d2006071b0d 100644
--- a/test_programs/execution_success/brillig_calls_array/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_array/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is brillig calls passing arrays around
 fn main(x: [u32; 3]) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(entry_point(x) == 9);
         another_entry_point(x);
diff --git a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
index 31b70cb12cf..e8bce638ebe 100644
--- a/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
+++ b/test_programs/execution_success/brillig_calls_conditionals/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is brillig calls with conditionals
 fn main(x: [u32; 3]) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(entry_point(x[0]) == 7);
         assert(entry_point(x[1]) == 8);
diff --git a/test_programs/execution_success/brillig_conditional/src/main.nr b/test_programs/execution_success/brillig_conditional/src/main.nr
index 024ee52d5af..c815d9966fe 100644
--- a/test_programs/execution_success/brillig_conditional/src/main.nr
+++ b/test_programs/execution_success/brillig_conditional/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is basic conditonal on brillig
 fn main(x: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(4 == conditional(x == 1));
     }
diff --git a/test_programs/execution_success/brillig_fns_as_values/src/main.nr b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
index ff1c36c9ddf..486262f2a86 100644
--- a/test_programs/execution_success/brillig_fns_as_values/src/main.nr
+++ b/test_programs/execution_success/brillig_fns_as_values/src/main.nr
@@ -3,7 +3,7 @@ struct MyStruct {
 }
 
 fn main(x: u32) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(wrapper(increment, x) == x + 1);
         assert(wrapper(increment_acir, x) == x + 1);
diff --git a/test_programs/execution_success/brillig_identity_function/src/main.nr b/test_programs/execution_success/brillig_identity_function/src/main.nr
index b676c46120e..c4f52d3e02b 100644
--- a/test_programs/execution_success/brillig_identity_function/src/main.nr
+++ b/test_programs/execution_success/brillig_identity_function/src/main.nr
@@ -6,7 +6,7 @@ struct myStruct {
 //
 // The features being tested is the identity function in Brillig
 fn main(x: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(x == identity(x));
         // TODO: add support for array comparison
diff --git a/test_programs/execution_success/brillig_nested_arrays/src/main.nr b/test_programs/execution_success/brillig_nested_arrays/src/main.nr
index feb5433738f..3f5e5a0f8eb 100644
--- a/test_programs/execution_success/brillig_nested_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_nested_arrays/src/main.nr
@@ -28,7 +28,7 @@ unconstrained fn create_and_assert_inside_brillig(x: Field, y: Field) {
 }
 
 fn main(x: Field, y: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let header = Header { params: [1, 2, 3] };
         let note0 = MyNote { array: [1, 2], plain: 3, header };
diff --git a/test_programs/execution_success/brillig_not/src/main.nr b/test_programs/execution_success/brillig_not/src/main.nr
index 6dc91f86127..e9e7c1bea81 100644
--- a/test_programs/execution_success/brillig_not/src/main.nr
+++ b/test_programs/execution_success/brillig_not/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The features being tested is not instruction on brillig
 fn main(x: Field, y: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(false == not_operator(x as bool));
         assert(true == not_operator(y as bool));
diff --git a/test_programs/execution_success/brillig_recursion/src/main.nr b/test_programs/execution_success/brillig_recursion/src/main.nr
index e7140ffa06c..8d8997834c7 100644
--- a/test_programs/execution_success/brillig_recursion/src/main.nr
+++ b/test_programs/execution_success/brillig_recursion/src/main.nr
@@ -2,7 +2,7 @@
 //
 // The feature being tested is brillig recursion
 fn main(x: u32) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(fibonacci(x) == 55);
     }
diff --git a/test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr b/test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr
index 39a13440ca9..03b1518cd35 100644
--- a/test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr
+++ b/test_programs/execution_success/brillig_uninitialized_arrays/src/main.nr
@@ -1,5 +1,5 @@
 fn main(x: Field, y: Field) -> pub Field {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let notes = create_notes(x, y);
         sum_x(notes, x, y)
diff --git a/test_programs/execution_success/dont_deduplicate_call/src/main.nr b/test_programs/execution_success/dont_deduplicate_call/src/main.nr
index cb658eab763..cec4d7fd38f 100644
--- a/test_programs/execution_success/dont_deduplicate_call/src/main.nr
+++ b/test_programs/execution_success/dont_deduplicate_call/src/main.nr
@@ -1,6 +1,6 @@
 fn main(x: Field, active: bool) {
     let mut x1 = false;
-    /// Safety:)
+    // Safety:)
     unsafe {
         if active {
             x1 = foo(x);
diff --git a/test_programs/execution_success/global_var_regression_entry_points/src/main.nr b/test_programs/execution_success/global_var_regression_entry_points/src/main.nr
index c55a6ac01e9..4a50be0881e 100644
--- a/test_programs/execution_success/global_var_regression_entry_points/src/main.nr
+++ b/test_programs/execution_success/global_var_regression_entry_points/src/main.nr
@@ -2,7 +2,7 @@ mod consts;
 use consts::EXPONENTIATE;
 
 fn main(x: Field, y: pub Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert(entry_point_only_const_global(x) == 2);
         check_acc_entry_point(x, y);
diff --git a/test_programs/execution_success/hint_black_box/src/main.nr b/test_programs/execution_success/hint_black_box/src/main.nr
index ed2dc2d3760..0cc28383216 100644
--- a/test_programs/execution_success/hint_black_box/src/main.nr
+++ b/test_programs/execution_success/hint_black_box/src/main.nr
@@ -23,7 +23,7 @@ fn main(a: u32, b: u32) {
     //assert_eq(slice_sum(black_box(arr.as_slice())), b);
 
     // But we can pass a blackboxed slice to Brillig.
-    /// Safety: testing context
+    // Safety: testing context
     let s = unsafe { brillig_slice_sum(black_box(arr.as_slice())) };
     assert_eq(s, b);
 
diff --git a/test_programs/execution_success/loop_keyword/src/main.nr b/test_programs/execution_success/loop_keyword/src/main.nr
index b038ae22343..ccdc20bc16f 100644
--- a/test_programs/execution_success/loop_keyword/src/main.nr
+++ b/test_programs/execution_success/loop_keyword/src/main.nr
@@ -1,5 +1,5 @@
 fn main() {
-    /// Safety: test code
+    // Safety: test code
     unsafe {
         check_loop();
     }
diff --git a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
index f724d0cdedd..387454b9e21 100644
--- a/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
+++ b/test_programs/execution_success/nested_arrays_from_brillig/src/main.nr
@@ -20,7 +20,7 @@ unconstrained fn create_inside_brillig(values: [Field; 6]) -> [MyNote; 2] {
 }
 
 fn main(values: [Field; 6]) {
-    /// Safety: testing context
+    // Safety: testing context
     let notes = unsafe { create_inside_brillig(values) };
     assert(access_nested(notes) == (2 + 4 + 3 + 1));
 }
diff --git a/test_programs/execution_success/reference_counts/src/main.nr b/test_programs/execution_success/reference_counts/src/main.nr
index a4c573baf39..2ee8a13f7a4 100644
--- a/test_programs/execution_success/reference_counts/src/main.nr
+++ b/test_programs/execution_success/reference_counts/src/main.nr
@@ -15,7 +15,7 @@ fn main() {
     let rc2 = array_refcount(u32_array);
     borrow_mut_two_separate(&mut array, &mut u32_array, rc1, rc2);
 
-    /// Safety: test
+    // Safety: test
     unsafe {
         regression_7297();
     }
diff --git a/test_programs/execution_success/reference_only_used_as_alias/src/main.nr b/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
index 3bbf1cf9ccb..c8dd38d9aca 100644
--- a/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
+++ b/test_programs/execution_success/reference_only_used_as_alias/src/main.nr
@@ -61,7 +61,7 @@ where
     Event: EventInterface,
 {
     |e: Event| {
-        /// Safety: testing context
+        // Safety: testing context
         unsafe {
             func(context.a);
         }
diff --git a/test_programs/execution_success/regression_5435/src/main.nr b/test_programs/execution_success/regression_5435/src/main.nr
index a83ca055aab..7242dc48ce3 100644
--- a/test_programs/execution_success/regression_5435/src/main.nr
+++ b/test_programs/execution_success/regression_5435/src/main.nr
@@ -3,7 +3,7 @@ fn main(input: Field, enable: bool) {
         let hash = no_predicate_function(input);
         // `EnableSideEffects` instruction from above instruction leaks out and removes the predicate from this call,
         // resulting in execution failure.
-        /// Safety: testing context
+        // Safety: testing context
         unsafe { fail(hash) };
     }
 }
diff --git a/test_programs/execution_success/regression_6451/src/main.nr b/test_programs/execution_success/regression_6451/src/main.nr
index edef71020e4..a20104d894e 100644
--- a/test_programs/execution_success/regression_6451/src/main.nr
+++ b/test_programs/execution_success/regression_6451/src/main.nr
@@ -10,7 +10,7 @@ fn main(x: Field) {
     value.assert_max_bit_size::<1>();
 
     // Regression test for #6447 (Aztec Packages issue #9488)
-    /// Safety: testing context
+    // Safety: testing context
     let y = unsafe { empty(x + 1) };
     let z = y + x + 1;
     let z1 = z + y;
diff --git a/test_programs/execution_success/regression_7062/src/main.nr b/test_programs/execution_success/regression_7062/src/main.nr
index 47e7593c0e6..726eacad30e 100644
--- a/test_programs/execution_success/regression_7062/src/main.nr
+++ b/test_programs/execution_success/regression_7062/src/main.nr
@@ -1,7 +1,7 @@
 fn main(value: Field, index: u32) {
     let mut args = &[0, 1];
     args[index] = value;
-    /// Safety: n/a
+    // Safety: n/a
     unsafe { store(args) };
     // Dummy test to remove the 'underconstraint bug'
     assert(args[0] + args[1] != 0);
diff --git a/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr b/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
index b4dd6a57e80..9fd97ad7f2b 100644
--- a/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
+++ b/test_programs/execution_success/regression_unsafe_no_predicates/src/main.nr
@@ -7,7 +7,7 @@ fn main(x: u8, nest: bool) {
 
 #[no_predicates]
 pub fn unsafe_assert<let N: u32>(msg: [u8; N]) -> u8 {
-    /// Safety: testing context
+    // Safety: testing context
     let block = unsafe { get_block(msg) };
     verify_block(msg, block);
     block[0]
diff --git a/test_programs/execution_success/u16_support/src/main.nr b/test_programs/execution_success/u16_support/src/main.nr
index d86ad348708..ceaf45a3fc6 100644
--- a/test_programs/execution_success/u16_support/src/main.nr
+++ b/test_programs/execution_success/u16_support/src/main.nr
@@ -1,6 +1,6 @@
 fn main(x: u16) {
     test_u16(x);
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         test_u16_unconstrained(x);
     }
diff --git a/test_programs/execution_success/uhashmap/src/main.nr b/test_programs/execution_success/uhashmap/src/main.nr
index 6163d5b954b..4015559f11d 100644
--- a/test_programs/execution_success/uhashmap/src/main.nr
+++ b/test_programs/execution_success/uhashmap/src/main.nr
@@ -293,7 +293,7 @@ unconstrained fn doc_tests() {
 
 // docs:start:get_example
 fn get_example(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hasher>>) {
-    /// Safety: testing context
+    // Safety: testing context
     let x = unsafe { map.get(12) };
 
     if x.is_some() {
@@ -319,7 +319,7 @@ fn entries_examples(map: UHashMap<Field, Field, BuildHasherDefault<Poseidon2Hash
     let keys = map.keys();
 
     for key in keys {
-        /// Safety: testing context
+        // Safety: testing context
         let value = unsafe { map.get(key) }.unwrap_unchecked();
         println(f"{key} -> {value}");
     }
diff --git a/test_programs/format.sh b/test_programs/format.sh
index fa63d228752..4f6f3e21916 100755
--- a/test_programs/format.sh
+++ b/test_programs/format.sh
@@ -33,7 +33,11 @@ echo "[workspace]" > Nargo.toml
 echo "members = [" >> Nargo.toml
 
 collect_dirs compile_success_empty
+# collect_dirs compile_success_contract
+collect_dirs compile_success_no_bug
+collect_dirs compile_success_with_bug
 collect_dirs execution_success
+collect_dirs noir_test_success
 
 echo "]" >> Nargo.toml
 
diff --git a/test_programs/noir_test_success/brillig_oracle/src/main.nr b/test_programs/noir_test_success/brillig_oracle/src/main.nr
index 77dbeef9aa1..b0ffb1a0d88 100644
--- a/test_programs/noir_test_success/brillig_oracle/src/main.nr
+++ b/test_programs/noir_test_success/brillig_oracle/src/main.nr
@@ -8,7 +8,7 @@ fn test_main() {
 
 // Tests oracle usage in brillig/unconstrained functions
 fn main(_x: Field) {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let size = 20;
         // TODO: Add a method along the lines of `(0..size).to_array()`.
diff --git a/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
index 35a0c44218f..019f757591e 100644
--- a/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
+++ b/test_programs/noir_test_success/brillig_overflow_checks/src/main.nr
@@ -1,4 +1,4 @@
-use std::field::bn254::{TWO_POW_128, assert_gt};
+use std::field::bn254::{assert_gt, TWO_POW_128};
 
 #[test(should_fail_with = "attempt to add with overflow")]
 unconstrained fn test_overflow_add() {
diff --git a/test_programs/noir_test_success/comptime_blackbox/src/main.nr b/test_programs/noir_test_success/comptime_blackbox/src/main.nr
index 859790f7d2d..c5ca59c7afc 100644
--- a/test_programs/noir_test_success/comptime_blackbox/src/main.nr
+++ b/test_programs/noir_test_success/comptime_blackbox/src/main.nr
@@ -75,13 +75,31 @@ fn test_blake3() {
 #[test]
 fn test_ecdsa_secp256k1() {
     let (valid_array, valid_slice) = comptime {
-        let pub_key_x: [u8; 32] = hex_to_bytes("a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7").as_array();
-        let pub_key_y: [u8; 32] = hex_to_bytes("893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7").as_array();
-        let signature: [u8; 64] = hex_to_bytes("e5081c80ab427dc370346f4a0e31aa2bad8d9798c38061db9ae55a4e8df454fd28119894344e71b78770cc931d61f480ecbb0b89d6eb69690161e49a715fcd55").as_array();
-        let hashed_message: [u8; 32] = hex_to_bytes("3a73f4123a5cd2121f21cd7e8d358835476949d035d9c2da6806b4633ac8c1e2").as_array();
+        let pub_key_x: [u8; 32] = hex_to_bytes(
+            "a0434d9e47f3c86235477c7b1ae6ae5d3442d49b1943c2b752a68e2a47e247c7",
+        )
+            .as_array();
+        let pub_key_y: [u8; 32] = hex_to_bytes(
+            "893aba425419bc27a3b6c7e693a24c696f794c2ed877a1593cbee53b037368d7",
+        )
+            .as_array();
+        let signature: [u8; 64] = hex_to_bytes(
+            "e5081c80ab427dc370346f4a0e31aa2bad8d9798c38061db9ae55a4e8df454fd28119894344e71b78770cc931d61f480ecbb0b89d6eb69690161e49a715fcd55",
+        )
+            .as_array();
+        let hashed_message: [u8; 32] = hex_to_bytes(
+            "3a73f4123a5cd2121f21cd7e8d358835476949d035d9c2da6806b4633ac8c1e2",
+        )
+            .as_array();
 
-        let valid_array = std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
-        let valid_slice = std::ecdsa_secp256k1::verify_signature_slice(pub_key_x, pub_key_y, signature, hashed_message.as_slice());
+        let valid_array =
+            std::ecdsa_secp256k1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+        let valid_slice = std::ecdsa_secp256k1::verify_signature_slice(
+            pub_key_x,
+            pub_key_y,
+            signature,
+            hashed_message.as_slice(),
+        );
 
         (valid_array, valid_slice)
     };
@@ -93,13 +111,31 @@ fn test_ecdsa_secp256k1() {
 #[test]
 fn test_ecdsa_secp256r1() {
     let (valid_array, valid_slice) = comptime {
-        let pub_key_x: [u8; 32] = hex_to_bytes("550f471003f3df97c3df506ac797f6721fb1a1fb7b8f6f83d224498a65c88e24").as_array();
-        let pub_key_y: [u8; 32] = hex_to_bytes("136093d7012e509a73715cbd0b00a3cc0ff4b5c01b3ffa196ab1fb327036b8e6").as_array();
-        let signature: [u8; 64] = hex_to_bytes("2c70a8d084b62bfc5ce03641caf9f72ad4da8c81bfe6ec9487bb5e1bef62a13218ad9ee29eaf351fdc50f1520c425e9b908a07278b43b0ec7b872778c14e0784").as_array();
-        let hashed_message: [u8; 32] = hex_to_bytes("54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad").as_array();
+        let pub_key_x: [u8; 32] = hex_to_bytes(
+            "550f471003f3df97c3df506ac797f6721fb1a1fb7b8f6f83d224498a65c88e24",
+        )
+            .as_array();
+        let pub_key_y: [u8; 32] = hex_to_bytes(
+            "136093d7012e509a73715cbd0b00a3cc0ff4b5c01b3ffa196ab1fb327036b8e6",
+        )
+            .as_array();
+        let signature: [u8; 64] = hex_to_bytes(
+            "2c70a8d084b62bfc5ce03641caf9f72ad4da8c81bfe6ec9487bb5e1bef62a13218ad9ee29eaf351fdc50f1520c425e9b908a07278b43b0ec7b872778c14e0784",
+        )
+            .as_array();
+        let hashed_message: [u8; 32] = hex_to_bytes(
+            "54705ba3baafdbdfba8c5f9a70f7a89bee98d906b53e31074da7baecdc0da9ad",
+        )
+            .as_array();
 
-        let valid_array = std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
-        let valid_slice = std::ecdsa_secp256r1::verify_signature_slice(pub_key_x, pub_key_y, signature, hashed_message.as_slice());
+        let valid_array =
+            std::ecdsa_secp256r1::verify_signature(pub_key_x, pub_key_y, signature, hashed_message);
+        let valid_slice = std::ecdsa_secp256r1::verify_signature_slice(
+            pub_key_x,
+            pub_key_y,
+            signature,
+            hashed_message.as_slice(),
+        );
         (valid_array, valid_slice)
     };
     assert(valid_array);
@@ -123,7 +159,11 @@ fn test_embedded_curve_ops() {
     let (sum, mul) = comptime {
         let s1 = EmbeddedCurveScalar { lo: 1, hi: 0 };
         let s2 = EmbeddedCurveScalar { lo: 2, hi: 0 };
-        let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+        let g1 = EmbeddedCurvePoint {
+            x: 1,
+            y: 17631683881184975370165255887551781615748388533673675138860,
+            is_infinite: false,
+        };
         let g2 = multi_scalar_mul([g1], [s2]);
         let sum = g1 + g2;
         let mul = multi_scalar_mul([g1, g2], [s1, s1]);
@@ -138,7 +178,7 @@ comptime fn hex_to_bytes<let N: u32>(s: str<N>) -> [u8] {
     let mut out = &[];
     let bz = s.as_bytes();
     let mut h: u32 = 0;
-    for i in 0 .. bz.len() {
+    for i in 0..bz.len() {
         let ascii = bz[i];
         let d = if ascii < 58 {
             ascii - 48
diff --git a/test_programs/noir_test_success/comptime_expr/src/main.nr b/test_programs/noir_test_success/comptime_expr/src/main.nr
index 6efbc212cbe..1b20104cf00 100644
--- a/test_programs/noir_test_success/comptime_expr/src/main.nr
+++ b/test_programs/noir_test_success/comptime_expr/src/main.nr
@@ -554,7 +554,7 @@ mod tests {
     fn test_expr_as_unsafe() {
         comptime {
             let expr = quote {  
-                /// Safety: test
+                // Safety: test
                 unsafe { 1; 4; 23 } 
                 }
                 .as_expr()
@@ -568,7 +568,7 @@ mod tests {
     fn test_expr_modify_for_unsafe() {
         comptime {
             let expr = quote { 
-                /// Safety: test
+                // Safety: test
                 unsafe { 1; 4; 23 } 
             }
                 .as_expr()
diff --git a/test_programs/noir_test_success/comptime_globals/src/main.nr b/test_programs/noir_test_success/comptime_globals/src/main.nr
index 95c54b96609..6033635b17e 100644
--- a/test_programs/noir_test_success/comptime_globals/src/main.nr
+++ b/test_programs/noir_test_success/comptime_globals/src/main.nr
@@ -7,7 +7,11 @@ comptime global FOO: Field = foo();
 // is evaluated before loop unrolling.
 comptime fn foo() -> Field {
     let mut three = 3;
-    if three == 3 { 5 } else { 6 }
+    if three == 3 {
+        5
+    } else {
+        6
+    }
 }
 
 #[test]
diff --git a/test_programs/noir_test_success/embedded_curve_ops/src/main.nr b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
index 760df58c34a..1deb826e5e2 100644
--- a/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
+++ b/test_programs/noir_test_success/embedded_curve_ops/src/main.nr
@@ -1,10 +1,14 @@
 use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_scalar_mul};
 
 #[test]
-    
- fn test_infinite_point() {
+
+fn test_infinite_point() {
     let zero = EmbeddedCurvePoint::point_at_infinity();
-    let g1 = EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false };
+    let g1 = EmbeddedCurvePoint {
+        x: 1,
+        y: 17631683881184975370165255887551781615748388533673675138860,
+        is_infinite: false,
+    };
     let g2 = g1 + g1;
 
     let s1 = EmbeddedCurveScalar { lo: 1, hi: 0 };
@@ -16,21 +20,25 @@ use std::embedded_curve_ops::{EmbeddedCurvePoint, EmbeddedCurveScalar, multi_sca
     assert(zero + zero == zero);
     assert(
         multi_scalar_mul([g1], [s1])
-        == EmbeddedCurvePoint { x: 1, y: 17631683881184975370165255887551781615748388533673675138860, is_infinite: false }
+            == EmbeddedCurvePoint {
+                x: 1,
+                y: 17631683881184975370165255887551781615748388533673675138860,
+                is_infinite: false,
+            },
     );
     assert(multi_scalar_mul([g1, g1], [s1, s1]) == g2);
     assert(
         multi_scalar_mul(
-        [g1, zero],
-        [EmbeddedCurveScalar { lo: 2, hi: 0 }, EmbeddedCurveScalar { lo: 42, hi: 25 }]
-    )
-        == g2
+            [g1, zero],
+            [EmbeddedCurveScalar { lo: 2, hi: 0 }, EmbeddedCurveScalar { lo: 42, hi: 25 }],
+        )
+            == g2,
     );
     assert(
         multi_scalar_mul(
-        [g1, g1, zero],
-        [s1, s1, EmbeddedCurveScalar { lo: 42, hi: 25 }]
-    )
-        == g2
+            [g1, g1, zero],
+            [s1, s1, EmbeddedCurveScalar { lo: 42, hi: 25 }],
+        )
+            == g2,
     );
 }
diff --git a/test_programs/noir_test_success/field_comparisons/src/main.nr b/test_programs/noir_test_success/field_comparisons/src/main.nr
index 8613e6d6c4f..5bd24008b21 100644
--- a/test_programs/noir_test_success/field_comparisons/src/main.nr
+++ b/test_programs/noir_test_success/field_comparisons/src/main.nr
@@ -1,4 +1,4 @@
-use std::field::bn254::{TWO_POW_128, assert_gt};
+use std::field::bn254::{assert_gt, TWO_POW_128};
 
 #[test(should_fail)]
 fn test_assert_gt_should_fail_eq() {
diff --git a/test_programs/noir_test_success/global_eval/src/main.nr b/test_programs/noir_test_success/global_eval/src/main.nr
index 6ec366c4cd6..87a2d50a916 100644
--- a/test_programs/noir_test_success/global_eval/src/main.nr
+++ b/test_programs/noir_test_success/global_eval/src/main.nr
@@ -10,8 +10,8 @@ global POW64_B: Field = (U128::one() << 64).to_integer();
 
 #[test]
 fn test_be_and_le_bits() {
-    assert_eq(BITS_BE_13, [1,1,0,1]);
-    assert_eq(BITS_LE_13, [1,0,1,1]);
+    assert_eq(BITS_BE_13, [1, 1, 0, 1]);
+    assert_eq(BITS_LE_13, [1, 0, 1, 1]);
 }
 
 #[test]
diff --git a/test_programs/noir_test_success/mock_oracle/src/main.nr b/test_programs/noir_test_success/mock_oracle/src/main.nr
index aaf2c87ddb0..bdffd62bb80 100644
--- a/test_programs/noir_test_success/mock_oracle/src/main.nr
+++ b/test_programs/noir_test_success/mock_oracle/src/main.nr
@@ -34,7 +34,7 @@ unconstrained fn struct_field(point: Point, array: [Field; 4]) -> Field {
 
 #[test(should_fail)]
 fn test_mock_no_returns() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("void_field");
         void_field(); // Some return value must be set
@@ -43,7 +43,7 @@ fn test_mock_no_returns() {
 
 #[test]
 fn test_mock() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("void_field").returns(10);
         assert_eq(void_field(), 10);
@@ -52,7 +52,7 @@ fn test_mock() {
 
 #[test]
 fn test_multiple_mock() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let first_mock = OracleMock::mock("void_field").returns(10);
         OracleMock::mock("void_field").returns(42);
@@ -67,7 +67,7 @@ fn test_multiple_mock() {
 
 #[test]
 fn test_multiple_mock_times() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("void_field").returns(10).times(2);
         OracleMock::mock("void_field").returns(42);
@@ -80,7 +80,7 @@ fn test_multiple_mock_times() {
 
 #[test]
 fn test_mock_with_params() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("field_field").with_params((5,)).returns(10);
         assert_eq(field_field(5), 10);
@@ -89,7 +89,7 @@ fn test_mock_with_params() {
 
 #[test]
 fn test_multiple_mock_with_params() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("field_field").with_params((5,)).returns(10);
         OracleMock::mock("field_field").with_params((7,)).returns(14);
@@ -101,7 +101,7 @@ fn test_multiple_mock_with_params() {
 
 #[test]
 fn test_mock_last_params() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let mock = OracleMock::mock("field_field").returns(10);
         assert_eq(field_field(5), 10);
@@ -112,7 +112,7 @@ fn test_mock_last_params() {
 
 #[test]
 fn test_mock_last_params_many_calls() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         let mock = OracleMock::mock("field_field").returns(10);
         assert_eq(field_field(5), 10);
@@ -129,7 +129,7 @@ fn test_mock_struct_field() {
     let another_array = [4, 3, 2, 1];
     let point = Point { x: 14, y: 27 };
 
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         OracleMock::mock("struct_field").returns(42).times(2);
         let timeless_mock = OracleMock::mock("struct_field").returns(0);
diff --git a/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr b/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
index 05bc2a5ce13..8848b9ad001 100644
--- a/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
+++ b/test_programs/noir_test_success/out_of_bounds_alignment/src/main.nr
@@ -16,7 +16,7 @@ fn test_acir() {
 
 #[test(should_fail)]
 fn test_brillig() {
-    /// Safety: testing context
+    // Safety: testing context
     unsafe {
         assert_eq(out_of_bounds_unconstrained_wrapper([0; 50], [0; 50]), 0);
     }
diff --git a/test_programs/noir_test_success/regression_4561/src/main.nr b/test_programs/noir_test_success/regression_4561/src/main.nr
index 6a8b4bd61fb..d925ed01cd8 100644
--- a/test_programs/noir_test_success/regression_4561/src/main.nr
+++ b/test_programs/noir_test_success/regression_4561/src/main.nr
@@ -40,7 +40,10 @@ unconstrained fn two_nested_return_unconstrained() -> (Field, TReturn, Field, TR
 #[test]
 unconstrained fn two_nested_return() {
     OracleMock::mock("two_nested_return").returns((0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6]));
-    assert_eq(two_nested_return_unconstrained(), (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]));
+    assert_eq(
+        two_nested_return_unconstrained(),
+        (0, [[1, 2, 3], [4, 5, 6]], 7, [[1, 2, 3], [4, 5, 6]]),
+    );
 }
 
 #[oracle(foo_return)]
@@ -58,18 +61,20 @@ struct TestTypeFoo {
 
 #[test]
 unconstrained fn complexe_struct_return() {
-    OracleMock::mock("foo_return").returns(
-        (
-            0, [1, 2, 3, 4, 5, 6], 7, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 2, 3, 4, 5, 6]
-        )
-    );
+    OracleMock::mock("foo_return").returns((
+        0, [1, 2, 3, 4, 5, 6], 7,
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24],
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12], [1, 2, 3, 4, 5, 6],
+    ));
     let foo_x = foo_return_unconstrained();
     assert_eq((foo_x.0, foo_x.1), (0, [[1, 2, 3], [4, 5, 6]]));
     assert_eq(foo_x.2.a, 7);
     assert_eq(
-        foo_x.2.b, [
-        [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]], [[13, 14, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24]]
-    ]
+        foo_x.2.b,
+        [
+            [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]],
+            [[13, 14, 15], [16, 17, 18], [19, 20, 21], [22, 23, 24]],
+        ],
     );
     let a: TReturnElem = [1, 2, 3];
     let b: TReturnElem = [4, 5, 6];
diff --git a/tooling/nargo_fmt/src/formatter/doc_comments.rs b/tooling/nargo_fmt/src/formatter/doc_comments.rs
index ac2cae10c78..f591f09e729 100644
--- a/tooling/nargo_fmt/src/formatter/doc_comments.rs
+++ b/tooling/nargo_fmt/src/formatter/doc_comments.rs
@@ -36,6 +36,48 @@ impl<'a> Formatter<'a> {
             }
         }
     }
+
+    /// Formats outer doc comments, turning them into regular comments if they start with "Safety:"
+    pub(super) fn format_outer_doc_comments_checking_safety(&mut self) {
+        self.skip_comments_and_whitespace();
+
+        let is_safety = match &self.token {
+            Token::LineComment(comment, Some(DocStyle::Outer))
+            | Token::BlockComment(comment, Some(DocStyle::Outer)) => {
+                comment.trim().to_lowercase().starts_with("safety:")
+            }
+            _ => false,
+        };
+        if !is_safety {
+            return self.format_outer_doc_comments();
+        }
+
+        loop {
+            self.skip_comments_and_whitespace();
+
+            match self.token {
+                Token::LineComment(_, Some(DocStyle::Outer)) => {
+                    self.write_indentation();
+                    let string = self.token.to_string();
+                    let string = string.trim_end();
+                    let string = string.replacen("///", "//", 1);
+                    self.write(&string);
+                    self.bump();
+                    self.write_line();
+                }
+                Token::BlockComment(_, Some(DocStyle::Outer)) => {
+                    self.write_indentation();
+                    let string = self.token.to_string();
+                    let string = string.trim_end();
+                    let string = string.replacen("/**", "/*", 1);
+                    self.write(&string);
+                    self.bump();
+                    self.write_line();
+                }
+                _ => break,
+            }
+        }
+    }
 }
 
 #[cfg(test)]
diff --git a/tooling/nargo_fmt/src/formatter/expression.rs b/tooling/nargo_fmt/src/formatter/expression.rs
index 54d9d2e41f5..1a6610364f2 100644
--- a/tooling/nargo_fmt/src/formatter/expression.rs
+++ b/tooling/nargo_fmt/src/formatter/expression.rs
@@ -377,7 +377,7 @@ impl<'a, 'b> ChunkFormatter<'a, 'b> {
     ) -> ChunkGroup {
         let mut group = ChunkGroup::new();
         group.text(self.chunk(|formatter| {
-            formatter.format_outer_doc_comments();
+            formatter.format_outer_doc_comments_checking_safety();
             formatter.write_keyword(Keyword::Unsafe);
             formatter.write_space();
         }));
@@ -2033,12 +2033,12 @@ global y = 1;
     }
 
     #[test]
-    fn format_unsafe_with_doc_comment() {
+    fn format_unsafe_with_comment() {
         let src = "fn foo() {
-        /// Comment 
+        // Comment 
         unsafe { 1  } }";
         let expected = "fn foo() {
-    /// Comment
+    // Comment
     unsafe {
         1
     }
@@ -2047,6 +2047,25 @@ global y = 1;
         assert_format(src, expected);
     }
 
+    #[test]
+    fn format_unsafe_with_doc_comment() {
+        let src = "fn foo() {
+        assert(
+        /// Safety: comment
+        /// More comments...
+        unsafe { 1  }
+        ); } ";
+        let expected = "fn foo() {
+    assert(
+        // Safety: comment
+        // More comments...
+        unsafe { 1 },
+    );
+}
+";
+        assert_format(src, expected);
+    }
+
     #[test]
     fn format_comptime_one_expression() {
         let src = "global x = comptime { 1  } ;";
diff --git a/tooling/nargo_fmt/src/formatter/statement.rs b/tooling/nargo_fmt/src/formatter/statement.rs
index ae4177c224b..7ce5801cf36 100644
--- a/tooling/nargo_fmt/src/formatter/statement.rs
+++ b/tooling/nargo_fmt/src/formatter/statement.rs
@@ -24,14 +24,14 @@ impl<'a, 'b> ChunkFormatter<'a, 'b> {
         group.leading_comment(self.chunk(|formatter| {
             // Doc comments for a let statement could come before a potential non-doc comment
             if formatter.token.kind() == TokenKind::OuterDocComment {
-                formatter.format_outer_doc_comments();
+                formatter.format_outer_doc_comments_checking_safety();
             }
 
             formatter.skip_comments_and_whitespace_writing_multiple_lines_if_found();
 
             // Or doc comments could come after a potential non-doc comment
             if formatter.token.kind() == TokenKind::OuterDocComment {
-                formatter.format_outer_doc_comments();
+                formatter.format_outer_doc_comments_checking_safety();
             }
         }));
 
@@ -374,12 +374,12 @@ mod tests {
     }
 
     #[test]
-    fn format_let_statement_with_unsafe() {
+    fn format_let_statement_with_unsafe_comment() {
         let src = " fn foo() { 
-        /// Safety: some doc
+        // Safety: some comment
         let  x  =  unsafe { 1 } ; } ";
         let expected = "fn foo() {
-    /// Safety: some doc
+    // Safety: some comment
     let x = unsafe { 1 };
 }
 ";
@@ -387,14 +387,12 @@ mod tests {
     }
 
     #[test]
-    fn format_let_statement_with_unsafe_and_comment_before_it() {
+    fn format_let_statement_with_unsafe_doc_comment() {
         let src = " fn foo() { 
-        // Some comment
-        /// Safety: some doc
+        /// Safety: some comment
         let  x  =  unsafe { 1 } ; } ";
         let expected = "fn foo() {
-    // Some comment
-    /// Safety: some doc
+    // Safety: some comment
     let x = unsafe { 1 };
 }
 ";
diff --git a/tooling/nargo_fmt/tests/expected/unsafe.nr b/tooling/nargo_fmt/tests/expected/unsafe.nr
index 0cf587ea549..265cba9604f 100644
--- a/tooling/nargo_fmt/tests/expected/unsafe.nr
+++ b/tooling/nargo_fmt/tests/expected/unsafe.nr
@@ -1,8 +1,13 @@
 fn main(x: pub u8, y: u8) {
-    /// Safety: testing
+    // Safety: testing
     unsafe {}
 
-    /// Safety: testing
+    // Safety: testing
+    unsafe {
+        assert_eq(x, y);
+    }
+
+    // Safety: testing
     unsafe {
         assert_eq(x, y);
     }
diff --git a/tooling/nargo_fmt/tests/input/unsafe.nr b/tooling/nargo_fmt/tests/input/unsafe.nr
index 0aeffd0b983..6e9319fcb17 100644
--- a/tooling/nargo_fmt/tests/input/unsafe.nr
+++ b/tooling/nargo_fmt/tests/input/unsafe.nr
@@ -1,8 +1,13 @@
 fn main(x: pub u8, y: u8) {
-    /// Safety: testing
+    // Safety: testing
     unsafe {
     }
 
+    // Safety: testing
+    unsafe {
+        assert_eq(x, y);
+    }
+
     /// Safety: testing
     unsafe {
         assert_eq(x, y);