feat: Allow methods defined in a contract to be non-entry points

compiler/noirc_driver/src/lib.rs

@@ -161,7 +161,7 @@
     let compiled_program = compile_no_check(context, options, main)?;
 
     if options.print_acir {
         println!("Compiled ACIR for main (unoptimized):");
         println!("{}", compiled_program.circuit);
     }
 
@@ -204,7 +204,7 @@
         if options.print_acir {
             for contract_function in &compiled_contract.functions {
                 println!(
                     "Compiled ACIR for {}::{} (unoptimized):",
                     compiled_contract.name, contract_function.name
                 );
                 println!("{}", contract_function.bytecode);
@@ -232,16 +232,28 @@
 ) -> Result<CompiledContract, ErrorsAndWarnings> {
     let mut functions = Vec::new();
     let mut errors = Vec::new();
-    for function_id in &contract.functions {
-        let name = context.function_name(function_id).to_owned();
-        let function = match compile_no_check(context, options, *function_id) {
+    for contract_function in &contract.functions {
+        let function_id = contract_function.function_id;
+        let is_entry_point = contract_function.is_entry_point;
+
+        let name = context.function_name(&function_id).to_owned();
+
+        // We assume that functions have already been type checked.
+        // This is the exact same assumption that compile_no_check makes.
+        // If it is not an entry-point point, we can then just skip the
+        // compilation step. It will also not be added to the ABI.
+        if !is_entry_point {
+            continue;
+        }
+
+        let function = match compile_no_check(context, options, function_id) {
             Ok(function) => function,
             Err(new_error) => {
                 errors.push(new_error);
                 continue;
             }
         };
-        let func_meta = context.def_interner.function_meta(function_id);
+        let func_meta = context.def_interner.function_meta(&function_id);
         let func_type = func_meta
             .contract_function_type
             .expect("Expected contract function to have a contract visibility");

compiler/noirc_frontend/src/hir/def_map/mod.rs

@@ -155,13 +155,23 @@ impl CrateDefMap {
 
     /// Go through all modules in this crate, find all `contract ... { ... }` declarations,
     /// and collect them all into a Vec.
-    pub fn get_all_contracts(&self) -> Vec<Contract> {
+    pub fn get_all_contracts(&self, interner: &NodeInterner) -> Vec<Contract> {
         self.modules
             .iter()
             .filter_map(|(id, module)| {
                 if module.is_contract {
-                    let functions =
+                    let function_ids: Vec<FuncId> =
                         module.value_definitions().filter_map(|id| id.as_function()).collect();
+
+                    let functions = function_ids
+                        .into_iter()
+                        .map(|id| {
+                            let is_entry_point =
+                                !interner.function_attributes(&id).has_contract_library_method();
+                            ContractFunctionMeta { function_id: id, is_entry_point }
+                        })
+                        .collect();
+
                     let name = self.get_module_path(id, module.parent);
                     Some(Contract { name, location: module.location, functions })
                 } else {
@@ -204,13 +214,25 @@ impl CrateDefMap {
     }
 }
 
+/// Specifies a contract function and extra metadata that
+/// one can use when processing a contract function.
+///
+/// One of these is whether the contract function is an entry point.
+/// The caller should only type-check these functions and not attempt
+/// to create a circuit for them.
+pub struct ContractFunctionMeta {
+    pub function_id: FuncId,
+    /// Indicates whether the function is an entry point
+    pub is_entry_point: bool,
+}
+
 /// A 'contract' in Noir source code with the given name and functions.
 /// This is not an AST node, it is just a convenient form to return for CrateDefMap::get_all_contracts.
 pub struct Contract {
     /// To keep `name` semi-unique, it is prefixed with the names of parent modules via CrateDefMap::get_module_path
     pub name: String,
     pub location: Location,
-    pub functions: Vec<FuncId>,
+    pub functions: Vec<ContractFunctionMeta>,
 }
 
 /// Given a FileId, fetch the File, from the FileManager and parse it's content

compiler/noirc_frontend/src/hir/mod.rs

@@ -168,7 +168,7 @@ impl Context {
     pub fn get_all_contracts(&self, crate_id: &CrateId) -> Vec<Contract> {
         self.def_map(crate_id)
             .expect("The local crate should be analyzed already")
-            .get_all_contracts()
+            .get_all_contracts(&self.def_interner)
     }
 
     fn module(&self, module_id: def_map::ModuleId) -> &def_map::ModuleData {

compiler/noirc_frontend/src/lexer/lexer.rs

@@ -536,6 +536,19 @@ mod tests {
             &Token::Attribute(Attribute::Primary(PrimaryAttribute::Test(TestScope::None)))
         );
     }
+
+    #[test]
+    fn contract_library_method_attribute() {
+        let input = r#"#[contract_library_method]"#;
+        let mut lexer = Lexer::new(input);
+
+        let token = lexer.next().unwrap().unwrap();
+        assert_eq!(
+            token.token(),
+            &Token::Attribute(Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod))
+        );
+    }
+
     #[test]
     fn test_attribute_with_valid_scope() {
         let input = r#"#[test(should_fail)]"#;

compiler/noirc_frontend/src/lexer/token.rs

@@ -332,7 +332,7 @@
         match string.trim() {
             "should_fail" => Some(TestScope::ShouldFailWith { reason: None }),
             s if s.starts_with("should_fail_with") => {
                 let parts: Vec<&str> = s.splitn(2, '=').collect();
                 if parts.len() == 2 {
                     let reason = parts[1].trim();
                     let reason = reason.trim_matches('"');
@@ -374,6 +374,16 @@
         Self { primary: None, secondary: Vec::new() }
     }
 
+    /// Returns true if one of the secondary attributes is `contract_library_method`
+    ///
+    /// This is useful for finding out if we should compile a contract method
+    /// as an entry point or not.
+    pub fn has_contract_library_method(&self) -> bool {
+        self.secondary
+            .iter()
+            .any(|attribute| attribute == &SecondaryAttribute::ContractLibraryMethod)
+    }
+
     /// Returns note if a deprecated secondary attribute is found
     pub fn get_deprecated_note(&self) -> Option<Option<String>> {
         self.secondary.iter().find_map(|attr| match attr {
@@ -454,6 +464,9 @@
             }
             // Secondary attributes
             ["deprecated"] => Attribute::Secondary(SecondaryAttribute::Deprecated(None)),
+            ["contract_library_method"] => {
+                Attribute::Secondary(SecondaryAttribute::ContractLibraryMethod)
+            }
             ["deprecated", name] => {
                 if !name.starts_with('"') && !name.ends_with('"') {
                     return Err(LexerErrorKind::MalformedFuncAttribute {
@@ -527,6 +540,10 @@
 #[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)]
 pub enum SecondaryAttribute {
     Deprecated(Option<String>),
+    // This is an attribute to specify that a function
+    // is a helper method for a contract and should not be seen as
+    // the entry point.
+    ContractLibraryMethod,
     Custom(String),
 }
 
@@ -538,6 +555,7 @@
                 write!(f, r#"#[deprecated("{note}")]"#)
             }
             SecondaryAttribute::Custom(ref k) => write!(f, "#[{k}]"),
+            SecondaryAttribute::ContractLibraryMethod => write!(f, "#[contract_library_method]"),
         }
     }
 }
@@ -559,6 +577,7 @@
             SecondaryAttribute::Deprecated(Some(string)) => string,
             SecondaryAttribute::Deprecated(None) => "",
             SecondaryAttribute::Custom(string) => string,
+            SecondaryAttribute::ContractLibraryMethod => "",
         }
     }
 }
@@ -623,7 +642,7 @@
             Keyword::Field => write!(f, "Field"),
             Keyword::Fn => write!(f, "fn"),
             Keyword::For => write!(f, "for"),
             Keyword::FormatString => write!(f, "fmtstr"),
             Keyword::Global => write!(f, "global"),
             Keyword::If => write!(f, "if"),
             Keyword::Impl => write!(f, "impl"),
@@ -666,7 +685,7 @@
             "Field" => Keyword::Field,
             "fn" => Keyword::Fn,
             "for" => Keyword::For,
             "fmtstr" => Keyword::FormatString,
             "global" => Keyword::Global,
             "if" => Keyword::If,
             "impl" => Keyword::Impl,

compiler/noirc_frontend/src/node_interner.rs

@@ -19,6 +19,7 @@
     function::{FuncMeta, HirFunction},
     stmt::HirStatement,
 };
+use crate::token::Attributes;
 use crate::{
     Generics, Shared, TypeAliasType, TypeBinding, TypeBindings, TypeVariable, TypeVariableId,
     TypeVariableKind,
@@ -76,7 +77,7 @@
     // Trait implementation map
     // For each type that implements a given Trait ( corresponding TraitId), there should be an entry here
     // The purpose for this hashmap is to detect duplication of trait implementations ( if any )
     trait_implementaions: HashMap<(Type, TraitId), Ident>,
 
     /// Map from ExprId (referring to a Function/Method call) to its corresponding TypeBindings,
     /// filled out during type checking from instantiated variables. Used during monomorphization
@@ -304,7 +305,7 @@
             structs: HashMap::new(),
             type_aliases: Vec::new(),
             traits: HashMap::new(),
             trait_implementaions: HashMap::new(),
             instantiation_bindings: HashMap::new(),
             field_indices: HashMap::new(),
             next_type_variable_id: 0,
@@ -547,6 +548,10 @@
         self.definition_name(name_id)
     }
 
+    pub fn function_attributes(&self, func_id: &FuncId) -> Attributes {
+        self.function_meta(func_id).attributes.clone()
+    }
+
     /// Returns the interned statement corresponding to `stmt_id`
     pub fn statement(&self, stmt_id: &StmtId) -> HirStatement {
         let def =
@@ -712,16 +717,16 @@
     }
 
     pub fn get_previous_trait_implementation(&self, key: &(Type, TraitId)) -> Option<&Ident> {
         self.trait_implementaions.get(key)
     }
 
     pub fn add_trait_implementaion(
         &mut self,
         key: &(Type, TraitId),
         trait_definition_ident: &Ident,
         methods: &UnresolvedFunctions,
     ) -> Vec<FuncId> {
         self.trait_implementaions.insert(key.clone(), trait_definition_ident.clone());
         methods
             .functions
             .iter()

tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/Nargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "no_entry_points"
+type = "contract"
+authors = [""]
+compiler_version = "0.1"
+
+[dependencies]

tooling/nargo_cli/tests/compile_success_contract/non_entry_point_method/src/main.nr

@@ -0,0 +1,6 @@
+contract Foo {
+    struct PlaceholderStruct{x : u32 }
+
+    #[contract_library_method]
+    fn has_mut(_context : &mut PlaceholderStruct) {}
+}