feat: #[allow(dead_code)]

compiler/noirc_frontend/src/elaborator/statements.rs

@@ -130,7 +130,7 @@ impl Elaborator<'_> {
         }
 
         let warn_if_unused =
-            !let_stmt.attributes.iter().any(|attr| attr.kind.is_allow_unused_variables());
+            !let_stmt.attributes.iter().any(|attr| attr.kind.is_allow("unused_variables"));
 
         let r#type = annotated_type;
         let pattern = self.elaborate_pattern_and_store_ids(

compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs

@@ -450,6 +450,8 @@
             let mut trait_definition = trait_definition.item;
             let name = trait_definition.name.clone();
             let location = trait_definition.location;
+            let has_allow_dead_code =
+                trait_definition.attributes.iter().any(|attr| attr.kind.is_allow("dead_code"));
 
             // Create the corresponding module for the trait namespace
             let trait_id = match self.push_child_module(
@@ -481,12 +483,14 @@
             );
 
             let parent_module_id = ModuleId { krate, local_id: self.module_id };
-            context.usage_tracker.add_unused_item(
-                parent_module_id,
-                name.clone(),
-                UnusedItem::Trait(trait_id),
-                visibility,
-            );
+            if !has_allow_dead_code {
+                context.usage_tracker.add_unused_item(
+                    parent_module_id,
+                    name.clone(),
+                    UnusedItem::Trait(trait_id),
+                    visibility,
+                );
+            }
 
             if let Err((first_def, second_def)) = result {
                 let error = DefCollectorErrorKind::Duplicate {
@@ -922,7 +926,7 @@
     //   if it's an inline module, or the first char of a the file if it's an external module.
     // - `location` will always point to the token "foo" in `mod foo` regardless of whether
     //   it's inline or external.
     // Eventually the location put in `ModuleData` is used for codelenses about `contract`s,
     // so we keep using `location` so that it continues to work as usual.
     let location = Location::new(mod_name.span(), mod_location.file);
     let new_module = ModuleData::new(
@@ -1013,6 +1017,7 @@
         function.name() == MAIN_FUNCTION
     };
     let has_export = function.def.attributes.has_export();
+    let has_allow_dead_code = function.def.attributes.has_allow("dead_code");
 
     let name = function.name_ident().clone();
     let func_id = interner.push_empty_fn();
@@ -1023,7 +1028,12 @@
         interner.register_function(func_id, &function.def);
     }
 
-    if !is_test && !is_fuzzing_harness && !is_entry_point_function && !has_export {
+    if !is_test
+        && !is_fuzzing_harness
+        && !is_entry_point_function
+        && !has_export
+        && !has_allow_dead_code
+    {
         let item = UnusedItem::Function(func_id);
         usage_tracker.add_unused_item(module, name.clone(), item, visibility);
     }
@@ -1109,7 +1119,10 @@
 
     let parent_module_id = ModuleId { krate, local_id: module_id };
 
-    if !unresolved.struct_def.is_abi() {
+    let has_allow_dead_code =
+        unresolved.struct_def.attributes.iter().any(|attr| attr.kind.is_allow("dead_code"));
+
+    if !unresolved.struct_def.is_abi() && !has_allow_dead_code {
         usage_tracker.add_unused_item(
             parent_module_id,
             name.clone(),
@@ -1200,7 +1213,10 @@
 
     let parent_module_id = ModuleId { krate, local_id: module_id };
 
-    if !unresolved.enum_def.is_abi() {
+    let has_allow_dead_code =
+        unresolved.enum_def.attributes.iter().any(|attr| attr.kind.is_allow("dead_code"));
+
+    if !unresolved.enum_def.is_abi() && !has_allow_dead_code {
         usage_tracker.add_unused_item(
             parent_module_id,
             name.clone(),

compiler/noirc_frontend/src/lexer/token.rs

@@ -748,7 +748,7 @@
     }
 }
 
 /// FuzzingScopr is used to specify additional annotations for fuzzing harnesses
 #[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
 pub enum FuzzingScope {
     /// If a fuzzing harness has a scope of OnlyFailWith, then it will only detect an assert
@@ -859,6 +859,10 @@
         self.has_secondary_attr(&SecondaryAttributeKind::Export)
     }
 
+    pub fn has_allow(&self, name: &'static str) -> bool {
+        self.secondary.iter().any(|attr| attr.kind.is_allow(name))
+    }
+
     /// Check if secondary attributes contain a specific instance.
     pub fn has_secondary_attr(&self, kind: &SecondaryAttributeKind) -> bool {
         self.secondary.iter().any(|attr| &attr.kind == kind)
@@ -1028,9 +1032,9 @@
 }
 
 impl SecondaryAttributeKind {
-    pub(crate) fn is_allow_unused_variables(&self) -> bool {
+    pub(crate) fn is_allow(&self, name: &'static str) -> bool {
         match self {
-            SecondaryAttributeKind::Allow(string) => string == "unused_variables",
+            SecondaryAttributeKind::Allow(string) => string == name,
             _ => false,
         }
     }

compiler/noirc_frontend/src/tests/unused_items.rs

@@ -409,3 +409,55 @@ fn does_not_consider_struct_as_constructed_if_mentioned_in_function_argument() {
     ";
     check_errors!(src);
 }
+
+#[named]
+#[test]
+fn allow_dead_code_on_unused_function() {
+    let src = "
+    #[allow(dead_code)]
+    fn foo() {}
+
+    fn main() {
+    }
+    ";
+    assert_no_errors!(src);
+}
+
+#[named]
+#[test]
+fn allow_dead_code_on_unused_struct() {
+    let src = "
+    #[allow(dead_code)]
+    struct Foo {}
+
+    fn main() {
+    }
+    ";
+    assert_no_errors!(src);
+}
+
+#[named]
+#[test]
+fn allow_dead_code_on_unused_trait() {
+    let src = "
+    #[allow(dead_code)]
+    trait Foo {}
+
+    fn main() {
+    }
+    ";
+    assert_no_errors!(src);
+}
+
+#[named]
+#[test]
+fn allow_dead_code_on_unused_enum() {
+    let src = "
+    #[allow(dead_code)]
+    enum Foo {}
+
+    fn main() {
+    }
+    ";
+    assert_no_errors!(src);
+}

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_enum/Nargo.toml

@@ -0,0 +1,7 @@
+
+            [package]
+            name = "noirc_frontend_tests_unused_items_allow_dead_code_on_unused_enum"
+            type = "bin"
+            authors = [""]
+
+            [dependencies]

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_enum/src/main.nr

@@ -0,0 +1,7 @@
+
+    #[allow(dead_code)]
+    enum Foo {}
+
+    fn main() {
+    }
+

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_enum/src_hash.txt

@@ -0,0 +1 @@
+2912787966510288424

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_function/Nargo.toml

@@ -0,0 +1,7 @@
+
+            [package]
+            name = "noirc_frontend_tests_unused_items_allow_dead_code_on_unused_function"
+            type = "bin"
+            authors = [""]
+
+            [dependencies]

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_function/src/main.nr

@@ -0,0 +1,7 @@
+
+    #[allow(dead_code)]
+    fn foo() {}
+
+    fn main() {
+    }
+

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_function/src_hash.txt

@@ -0,0 +1 @@
+8138537160766711355

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_struct/Nargo.toml

@@ -0,0 +1,7 @@
+
+            [package]
+            name = "noirc_frontend_tests_unused_items_allow_dead_code_on_unused_struct"
+            type = "bin"
+            authors = [""]
+
+            [dependencies]

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_struct/src/main.nr

@@ -0,0 +1,7 @@
+
+    #[allow(dead_code)]
+    struct Foo {}
+
+    fn main() {
+    }
+

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_struct/src_hash.txt

@@ -0,0 +1 @@
+14645872963190054969

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_trait/Nargo.toml

@@ -0,0 +1,7 @@
+
+            [package]
+            name = "noirc_frontend_tests_unused_items_allow_dead_code_on_unused_trait"
+            type = "bin"
+            authors = [""]
+
+            [dependencies]

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_trait/src/main.nr

@@ -0,0 +1,7 @@
+
+    #[allow(dead_code)]
+    trait Foo {}
+
+    fn main() {
+    }
+

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_trait/src_hash.txt

@@ -0,0 +1 @@
+14851478487121828974

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_type_alias/Nargo.toml

@@ -0,0 +1,7 @@
+
+            [package]
+            name = "noirc_frontend_tests_unused_items_allow_dead_code_on_unused_type_alias"
+            type = "bin"
+            authors = [""]
+
+            [dependencies]

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_type_alias/src/main.nr

@@ -0,0 +1,7 @@
+
+    #[allow(dead_code)]
+    type Foo = Field;
+
+    fn main() {
+    }
+

test_programs/compile_success_no_bug/noirc_frontend_tests_unused_items_allow_dead_code_on_unused_type_alias/src_hash.txt

@@ -0,0 +1 @@
+10281445062708207909

tooling/lsp/src/requests/completion/builtins.rs

@@ -88,12 +88,17 @@ impl NodeFinder<'_> {
 
     pub(super) fn suggest_builtin_attributes(&mut self, prefix: &str, target: AttributeTarget) {
         match target {
-            AttributeTarget::Module | AttributeTarget::Trait => (),
+            AttributeTarget::Module => (),
+            AttributeTarget::Trait => {
+                self.suggest_allow("dead_code", prefix);
+            }
             AttributeTarget::Struct => {
                 self.suggest_one_argument_attributes(prefix, &["abi"]);
+                self.suggest_allow("dead_code", prefix);
             }
             AttributeTarget::Enum => {
                 self.suggest_one_argument_attributes(prefix, &["abi"]);
+                self.suggest_allow("dead_code", prefix);
             }
             AttributeTarget::Function => {
                 let no_arguments_attributes = &[
@@ -147,18 +152,24 @@ impl NodeFinder<'_> {
                         None,
                     ));
                 }
+
+                self.suggest_allow("dead_code", prefix);
             }
             AttributeTarget::Let => {
-                if name_matches("allow", prefix) || name_matches("unused_variables", prefix) {
-                    self.completion_items.push(simple_completion_item(
-                        "allow(unused_variables)",
-                        CompletionItemKind::METHOD,
-                        None,
-                    ));
-                }
+                self.suggest_allow("unused_variables", prefix);
             }
         }
     }
+
+    fn suggest_allow(&mut self, name: &'static str, prefix: &str) {
+        if name_matches("allow", prefix) || name_matches(name, prefix) {
+            self.completion_items.push(simple_completion_item(
+                format!("allow({name})"),
+                CompletionItemKind::METHOD,
+                None,
+            ));
+        }
+    }
 }
 
 pub(super) fn builtin_integer_types() -> [&'static str; 9] {

tooling/lsp/src/requests/completion/tests.rs

@@ -2414,6 +2414,20 @@ fn main() {
         .await;
     }
 
+    #[test]
+    async fn test_suggests_built_in_allow_function_attribute() {
+        let src = r#"
+            #[dead_c>|<]
+            fn foo() {}
+        "#;
+
+        assert_completion_excluding_auto_import(
+            src,
+            vec![simple_completion_item("allow(dead_code)", CompletionItemKind::METHOD, None)],
+        )
+        .await;
+    }
+
     #[test]
     async fn test_suggests_built_in_let_attribute() {
         let src = r#"