diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
index 98555375790..3cfa0989d7d 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_crate.rs
@@ -8,6 +8,7 @@ use crate::hir::resolution::errors::ResolverError;
 use crate::hir::resolution::path_resolver;
 use crate::hir::type_check::TypeCheckError;
 use crate::token::SecondaryAttribute;
+use crate::usage_tracker::UnusedItem;
 use crate::{Generics, Type};
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
@@ -271,7 +272,7 @@ impl DefCollector {
         root_file_id: FileId,
         debug_comptime_in_file: Option<&str>,
         enable_arithmetic_generics: bool,
-        error_on_usage_tracker: bool,
+        error_on_unused_items: bool,
         macro_processors: &[&dyn MacroProcessor],
     ) -> Vec<(CompilationError, FileId)> {
         let mut errors: Vec<(CompilationError, FileId)> = vec![];
@@ -406,20 +407,14 @@ impl DefCollector {
                         let result = current_def_map.modules[resolved_import.module_scope.0]
                             .import(name.clone(), visibility, module_def_id, is_prelude);
 
-                        // Empty spans could come from implicitly injected imports, and we don't want to track those
-                        if visibility != ItemVisibility::Public
-                            && name.span().start() < name.span().end()
-                        {
-                            let module_id = ModuleId {
-                                krate: crate_id,
-                                local_id: resolved_import.module_scope,
-                            };
-
-                            context
-                                .def_interner
-                                .usage_tracker
-                                .add_unused_import(module_id, name.clone());
-                        }
+                        let module_id =
+                            ModuleId { krate: crate_id, local_id: resolved_import.module_scope };
+                        context.def_interner.usage_tracker.add_unused_item(
+                            module_id,
+                            name.clone(),
+                            UnusedItem::Import,
+                            visibility,
+                        );
 
                         if visibility != ItemVisibility::Private {
                             let local_id = resolved_import.module_scope;
@@ -494,26 +489,29 @@ impl DefCollector {
             );
         }
 
-        if error_on_usage_tracker {
-            Self::check_usage_tracker(context, crate_id, &mut errors);
+        if error_on_unused_items {
+            Self::check_unused_items(context, crate_id, &mut errors);
         }
 
         errors
     }
 
-    fn check_usage_tracker(
+    fn check_unused_items(
         context: &Context,
         crate_id: CrateId,
         errors: &mut Vec<(CompilationError, FileId)>,
     ) {
-        let unused_imports = context.def_interner.usage_tracker.unused_imports().iter();
+        let unused_imports = context.def_interner.usage_tracker.unused_items().iter();
         let unused_imports = unused_imports.filter(|(module_id, _)| module_id.krate == crate_id);
 
         errors.extend(unused_imports.flat_map(|(module_id, usage_tracker)| {
             let module = &context.def_maps[&crate_id].modules()[module_id.local_id.0];
-            usage_tracker.iter().map(|ident| {
+            usage_tracker.iter().map(|(ident, unused_item)| {
                 let ident = ident.clone();
-                let error = CompilationError::ResolverError(ResolverError::UnusedImport { ident });
+                let error = CompilationError::ResolverError(ResolverError::UnusedItem {
+                    ident,
+                    item_type: unused_item.item_type(),
+                });
                 (error, module.location.file)
             })
         }));
diff --git a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
index 79b55f60b76..6c1b7632a2e 100644
--- a/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
+++ b/compiler/noirc_frontend/src/hir/def_collector/dc_mod.rs
@@ -18,6 +18,7 @@ use crate::hir::resolution::errors::ResolverError;
 use crate::macros_api::{Expression, NodeInterner, StructId, UnresolvedType, UnresolvedTypeData};
 use crate::node_interner::ModuleAttributes;
 use crate::token::SecondaryAttribute;
+use crate::usage_tracker::UnusedItem;
 use crate::{
     graph::CrateId,
     hir::def_collector::dc_crate::{UnresolvedStruct, UnresolvedTrait},
@@ -36,7 +37,7 @@ use super::{
     },
     errors::{DefCollectorErrorKind, DuplicateType},
 };
-use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleData, ModuleId};
+use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleData, ModuleId, MAIN_FUNCTION};
 use crate::hir::resolution::import::ImportDirective;
 use crate::hir::Context;
 
@@ -833,6 +834,16 @@ pub fn collect_function(
             return None;
         }
     }
+
+    let module_data = &mut def_map.modules[module.local_id.0];
+
+    let is_test = function.def.attributes.is_test_function();
+    let is_entry_point_function = if module_data.is_contract {
+        function.attributes().is_contract_entry_point()
+    } else {
+        function.name() == MAIN_FUNCTION
+    };
+
     let name = function.name_ident().clone();
     let func_id = interner.push_empty_fn();
     let visibility = function.def.visibility;
@@ -841,6 +852,13 @@ pub fn collect_function(
     if interner.is_in_lsp_mode() && !function.def.is_test() {
         interner.register_function(func_id, &function.def);
     }
+
+    if !is_test && !is_entry_point_function {
+        let item = UnusedItem::Function(func_id);
+        interner.usage_tracker.add_unused_item(module, name.clone(), item, visibility);
+    }
+
+    // Add function to scope/ns of the module
     let result = def_map.modules[module.local_id.0].declare_function(name, visibility, func_id);
     if let Err((first_def, second_def)) = result {
         let error = DefCollectorErrorKind::Duplicate {
diff --git a/compiler/noirc_frontend/src/hir/resolution/errors.rs b/compiler/noirc_frontend/src/hir/resolution/errors.rs
index c2038c646b5..e74468bdf18 100644
--- a/compiler/noirc_frontend/src/hir/resolution/errors.rs
+++ b/compiler/noirc_frontend/src/hir/resolution/errors.rs
@@ -20,8 +20,8 @@ pub enum ResolverError {
     DuplicateDefinition { name: String, first_span: Span, second_span: Span },
     #[error("Unused variable")]
     UnusedVariable { ident: Ident },
-    #[error("Unused import")]
-    UnusedImport { ident: Ident },
+    #[error("Unused {item_type}")]
+    UnusedItem { ident: Ident, item_type: &'static str },
     #[error("Could not find variable in this scope")]
     VariableNotDeclared { name: String, span: Span },
     #[error("path is not an identifier")]
@@ -158,12 +158,12 @@ impl<'a> From<&'a ResolverError> for Diagnostic {
                 diagnostic.unnecessary = true;
                 diagnostic
             }
-            ResolverError::UnusedImport { ident } => {
+            ResolverError::UnusedItem { ident, item_type } => {
                 let name = &ident.0.contents;
 
                 let mut diagnostic = Diagnostic::simple_warning(
-                    format!("unused import {name}"),
-                    "unused import ".to_string(),
+                    format!("unused {item_type} {name}"),
+                    format!("unused {item_type}"),
                     ident.span(),
                 );
                 diagnostic.unnecessary = true;
diff --git a/compiler/noirc_frontend/src/node_interner.rs b/compiler/noirc_frontend/src/node_interner.rs
index 4a73df6a15f..aa51779d24b 100644
--- a/compiler/noirc_frontend/src/node_interner.rs
+++ b/compiler/noirc_frontend/src/node_interner.rs
@@ -655,7 +655,7 @@ impl Default for NodeInterner {
             auto_import_names: HashMap::default(),
             comptime_scopes: vec![HashMap::default()],
             trait_impl_associated_types: HashMap::default(),
-            usage_tracker: UsageTracker::default(),
+            usage_tracker: UsageTracker::new(),
         }
     }
 }
diff --git a/compiler/noirc_frontend/src/tests.rs b/compiler/noirc_frontend/src/tests.rs
index c6c8c5d4b4b..04c4e414858 100644
--- a/compiler/noirc_frontend/src/tests.rs
+++ b/compiler/noirc_frontend/src/tests.rs
@@ -1381,7 +1381,7 @@ fn ban_mutable_globals() {
 fn deny_inline_attribute_on_unconstrained() {
     let src = r#"
         #[no_predicates]
-        unconstrained fn foo(x: Field, y: Field) {
+        unconstrained pub fn foo(x: Field, y: Field) {
             assert(x != y);
         }
     "#;
@@ -1397,7 +1397,7 @@ fn deny_inline_attribute_on_unconstrained() {
 fn deny_fold_attribute_on_unconstrained() {
     let src = r#"
         #[fold]
-        unconstrained fn foo(x: Field, y: Field) {
+        unconstrained pub fn foo(x: Field, y: Field) {
             assert(x != y);
         }
     "#;
@@ -1554,7 +1554,7 @@ fn struct_numeric_generic_in_function() {
         inner: u64
     }
 
-    fn bar<let N: Foo>() { }
+    pub fn bar<let N: Foo>() { }
     "#;
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
@@ -1586,7 +1586,7 @@ fn struct_numeric_generic_in_struct() {
 #[test]
 fn bool_numeric_generic() {
     let src = r#"
-    fn read<let N: bool>() -> Field {
+    pub fn read<let N: bool>() -> Field {
         if N {
             0
         } else {
@@ -1605,7 +1605,7 @@ fn bool_numeric_generic() {
 #[test]
 fn numeric_generic_binary_operation_type_mismatch() {
     let src = r#"
-    fn foo<let N: Field>() -> bool {
+    pub fn foo<let N: Field>() -> bool {
         let mut check: bool = true;
         check = N;
         check
@@ -1622,7 +1622,7 @@ fn numeric_generic_binary_operation_type_mismatch() {
 #[test]
 fn bool_generic_as_loop_bound() {
     let src = r#"
-    fn read<let N: bool>() {
+    pub fn read<let N: bool>() {
         let mut fields = [0; N];
         for i in 0..N {
             fields[i] = i + 1;
@@ -1652,7 +1652,7 @@ fn bool_generic_as_loop_bound() {
 #[test]
 fn numeric_generic_in_function_signature() {
     let src = r#"
-    fn foo<let N: u8>(arr: [Field; N]) -> [Field; N] { arr }
+    pub fn foo<let N: u8>(arr: [Field; N]) -> [Field; N] { arr }
     "#;
     assert_no_errors(src);
 }
@@ -1694,7 +1694,7 @@ fn normal_generic_as_array_length() {
 #[test]
 fn numeric_generic_as_param_type() {
     let src = r#"
-    fn foo<let I: Field>(x: I) -> I {
+    pub fn foo<let I: Field>(x: I) -> I {
         let _q: I = 5;
         x
     }
@@ -1833,7 +1833,7 @@ fn numeric_generic_used_in_where_clause() {
         fn deserialize(fields: [Field; N]) -> Self;
     }
 
-    fn read<T, let N: u32>() -> T where T: Deserialize<N> {
+    pub fn read<T, let N: u32>() -> T where T: Deserialize<N> {
         let mut fields: [Field; N] = [0; N];
         for i in 0..N {
             fields[i] = i as Field + 1;
@@ -1847,12 +1847,12 @@ fn numeric_generic_used_in_where_clause() {
 #[test]
 fn numeric_generic_used_in_turbofish() {
     let src = r#"
-    fn double<let N: u32>() -> u32 {
+    pub fn double<let N: u32>() -> u32 {
         // Used as an expression
         N * 2
     }
 
-    fn double_numeric_generics_test() {
+    pub fn double_numeric_generics_test() {
         // Example usage of a numeric generic arguments.
         assert(double::<9>() == 18);
         assert(double::<7 + 8>() == 30);
@@ -1888,7 +1888,7 @@ fn normal_generic_used_when_numeric_expected_in_where_clause() {
         fn deserialize(fields: [Field; N]) -> Self;
     }
 
-    fn read<T, N>() -> T where T: Deserialize<N> {
+    pub fn read<T, N>() -> T where T: Deserialize<N> {
         T::deserialize([0, 1])
     }
     "#;
@@ -1904,7 +1904,7 @@ fn normal_generic_used_when_numeric_expected_in_where_clause() {
         fn deserialize(fields: [Field; N]) -> Self;
     }
 
-    fn read<T, N>() -> T where T: Deserialize<N> {
+    pub fn read<T, N>() -> T where T: Deserialize<N> {
         let mut fields: [Field; N] = [0; N];
         for i in 0..N {
             fields[i] = i as Field + 1;
@@ -2450,7 +2450,7 @@ fn use_super() {
     mod foo {
         use super::some_func;
 
-        fn bar() {
+        pub fn bar() {
             some_func();
         }
     }
@@ -2464,7 +2464,7 @@ fn use_super_in_path() {
     fn some_func() {}
 
     mod foo {
-        fn func() {
+        pub fn func() {
             super::some_func();
         }
     }
@@ -2755,7 +2755,7 @@ fn trait_constraint_on_tuple_type() {
             fn foo(self, x: A) -> bool;
         }
 
-        fn bar<T, U, V>(x: (T, U), y: V) -> bool where (T, U): Foo<V> {
+        pub fn bar<T, U, V>(x: (T, U), y: V) -> bool where (T, U): Foo<V> {
             x.foo(y)
         }
 
@@ -3091,7 +3091,7 @@ fn trait_impl_for_a_type_that_implements_another_trait() {
         }
     }
 
-    fn use_it<T>(t: T) -> i32 where T: Two {
+    pub fn use_it<T>(t: T) -> i32 where T: Two {
         Two::two(t)
     }
 
@@ -3131,7 +3131,7 @@ fn trait_impl_for_a_type_that_implements_another_trait_with_another_impl_used()
         }
     }
 
-    fn use_it(t: u32) -> i32 {
+    pub fn use_it(t: u32) -> i32 {
         Two::two(t)
     }
 
@@ -3243,12 +3243,14 @@ fn errors_on_unused_private_import() {
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 
-    let CompilationError::ResolverError(ResolverError::UnusedImport { ident }) = &errors[0].0
+    let CompilationError::ResolverError(ResolverError::UnusedItem { ident, item_type }) =
+        &errors[0].0
     else {
-        panic!("Expected an unused import error");
+        panic!("Expected an unused item error");
     };
 
     assert_eq!(ident.to_string(), "bar");
+    assert_eq!(*item_type, "import");
 }
 
 #[test]
@@ -3277,12 +3279,14 @@ fn errors_on_unused_pub_crate_import() {
     let errors = get_program_errors(src);
     assert_eq!(errors.len(), 1);
 
-    let CompilationError::ResolverError(ResolverError::UnusedImport { ident }) = &errors[0].0
+    let CompilationError::ResolverError(ResolverError::UnusedItem { ident, item_type }) =
+        &errors[0].0
     else {
-        panic!("Expected an unused import error");
+        panic!("Expected an unused item error");
     };
 
     assert_eq!(ident.to_string(), "bar");
+    assert_eq!(*item_type, "import");
 }
 
 #[test]
@@ -3295,7 +3299,7 @@ fn warns_on_use_of_private_exported_item() {
 
         use bar::baz;
 
-        fn qux() {
+        pub fn qux() {
             baz();
         }
     }
@@ -3369,7 +3373,7 @@ fn unoquted_integer_as_integer_token() {
     }
 
     #[attr]
-    fn foobar() {}
+    pub fn foobar() {}
 
     fn attr(_f: FunctionDefinition) -> Quoted {
         let serialized_len = 1;
@@ -3388,3 +3392,35 @@ fn unoquted_integer_as_integer_token() {
 
     assert_no_errors(src);
 }
+
+#[test]
+fn errors_on_unused_function() {
+    let src = r#"
+    contract some_contract {
+        // This function is unused, but it's a contract entrypoint
+        // so it should not produce a warning
+        fn foo() -> pub Field {
+            1
+        }
+    }
+
+
+    fn foo() {
+        bar();
+    }
+
+    fn bar() {}
+    "#;
+
+    let errors = get_program_errors(src);
+    assert_eq!(errors.len(), 1);
+
+    let CompilationError::ResolverError(ResolverError::UnusedItem { ident, item_type }) =
+        &errors[0].0
+    else {
+        panic!("Expected an unused item error");
+    };
+
+    assert_eq!(ident.to_string(), "foo");
+    assert_eq!(*item_type, "function");
+}
diff --git a/compiler/noirc_frontend/src/usage_tracker.rs b/compiler/noirc_frontend/src/usage_tracker.rs
index d8b7b271734..836f9824436 100644
--- a/compiler/noirc_frontend/src/usage_tracker.rs
+++ b/compiler/noirc_frontend/src/usage_tracker.rs
@@ -1,26 +1,54 @@
-use std::collections::HashSet;
+use std::collections::HashMap;
 
-use rustc_hash::FxHashMap as HashMap;
+use crate::{
+    ast::{Ident, ItemVisibility},
+    hir::def_map::ModuleId,
+    node_interner::FuncId,
+};
 
-use crate::{ast::Ident, hir::def_map::ModuleId};
+#[derive(Debug)]
+pub enum UnusedItem {
+    Import,
+    Function(FuncId),
+}
+
+impl UnusedItem {
+    pub fn item_type(&self) -> &'static str {
+        match self {
+            UnusedItem::Import => "import",
+            UnusedItem::Function(_) => "function",
+        }
+    }
+}
 
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct UsageTracker {
-    /// List of all unused imports in each module. Each time something is imported it's added
-    /// to the module's set. When it's used, it's removed. At the end of the program only unused imports remain.
-    unused_imports: HashMap<ModuleId, HashSet<Ident>>,
+    unused_items: HashMap<ModuleId, HashMap<Ident, UnusedItem>>,
 }
 
 impl UsageTracker {
-    pub(crate) fn add_unused_import(&mut self, module_id: ModuleId, name: Ident) {
-        self.unused_imports.entry(module_id).or_default().insert(name);
+    pub(crate) fn new() -> Self {
+        Self { unused_items: HashMap::new() }
+    }
+
+    pub(crate) fn add_unused_item(
+        &mut self,
+        module_id: ModuleId,
+        name: Ident,
+        item: UnusedItem,
+        visibility: ItemVisibility,
+    ) {
+        // Empty spans could come from implicitly injected imports, and we don't want to track those
+        if visibility != ItemVisibility::Public && name.span().start() < name.span().end() {
+            self.unused_items.entry(module_id).or_default().insert(name, item);
+        }
     }
 
     pub(crate) fn mark_as_used(&mut self, current_mod_id: ModuleId, name: &Ident) {
-        self.unused_imports.entry(current_mod_id).or_default().remove(name);
+        self.unused_items.entry(current_mod_id).or_default().remove(name);
     }
 
-    pub(crate) fn unused_imports(&self) -> &HashMap<ModuleId, HashSet<Ident>> {
-        &self.unused_imports
+    pub(crate) fn unused_items(&self) -> &HashMap<ModuleId, HashMap<Ident, UnusedItem>> {
+        &self.unused_items
     }
 }