feat: module attributes

aztec_macros/src/utils/parse_utils.rs

@@ -53,6 +53,7 @@ fn empty_item(item: &mut Item) {
         ItemKind::Import(use_tree, _) => empty_use_tree(use_tree),
         ItemKind::Struct(noir_struct) => empty_noir_struct(noir_struct),
         ItemKind::TypeAlias(noir_type_alias) => empty_noir_type_alias(noir_type_alias),
+        ItemKind::InnerAttribute(_) => (),
     }
 }
 

compiler/noirc_frontend/src/ast/statement.rs

@@ -292,6 +292,7 @@ pub trait Recoverable {
 #[derive(Debug, PartialEq, Eq, Clone)]
 pub struct ModuleDeclaration {
     pub ident: Ident,
+    pub outer_attributes: Vec<SecondaryAttribute>,
 }
 
 impl std::fmt::Display for ModuleDeclaration {

compiler/noirc_frontend/src/ast/visitor.rs

@@ -16,7 +16,7 @@
         QuotedTypeId,
     },
     parser::{Item, ItemKind, ParsedSubModule},
-    token::Tokens,
+    token::{SecondaryAttribute, Tokens},
     ParsedModule, QuotedType,
 };
 
@@ -432,6 +432,8 @@
     fn visit_struct_pattern(&mut self, _: &Path, _: &[(Ident, Pattern)], _: Span) -> bool {
         true
     }
+
+    fn visit_secondary_attribute(&mut self, _: &SecondaryAttribute, _: Span) {}
 }
 
 impl ParsedModule {
@@ -481,6 +483,9 @@
             ItemKind::ModuleDecl(module_declaration) => {
                 module_declaration.accept(self.span, visitor);
             }
+            ItemKind::InnerAttribute(attribute) => {
+                attribute.accept(self.span, visitor);
+            }
         }
     }
 }
@@ -1205,8 +1210,8 @@
             UnresolvedTypeData::Unspecified => visitor.visit_unspecified_type(self.span),
             UnresolvedTypeData::Quoted(typ) => visitor.visit_quoted_type(typ, self.span),
             UnresolvedTypeData::FieldElement => visitor.visit_field_element_type(self.span),
             UnresolvedTypeData::Integer(signdness, size) => {
                 visitor.visit_integer_type(*signdness, *size, self.span);
             }
             UnresolvedTypeData::Bool => visitor.visit_bool_type(self.span),
             UnresolvedTypeData::Unit => visitor.visit_unit_type(self.span),
@@ -1289,6 +1294,12 @@
     }
 }
 
+impl SecondaryAttribute {
+    pub fn accept(&self, span: Span, visitor: &mut impl Visitor) {
+        visitor.visit_secondary_attribute(self, span);
+    }
+}
+
 fn visit_expressions(expressions: &[Expression], visitor: &mut impl Visitor) {
     for expression in expressions {
         expression.accept(visitor);

compiler/noirc_frontend/src/elaborator/comptime.rs

@@ -10,11 +10,12 @@ use crate::{
         comptime::{Interpreter, InterpreterError, Value},
         def_collector::{
             dc_crate::{
-                CollectedItems, CompilationError, UnresolvedFunctions, UnresolvedStruct,
-                UnresolvedTrait, UnresolvedTraitImpl,
+                CollectedItems, CompilationError, ModuleAttribute, UnresolvedFunctions,
+                UnresolvedStruct, UnresolvedTrait, UnresolvedTraitImpl,
             },
             dc_mod,
         },
+        def_map::ModuleId,
         resolution::errors::ResolverError,
     },
     hir_def::expr::HirIdent,
@@ -96,21 +97,31 @@ impl<'context> Elaborator<'context> {
         generated_items: &mut CollectedItems,
     ) {
         for attribute in attributes {
-            if let SecondaryAttribute::Custom(attribute) = attribute {
-                if let Err(error) = self.run_comptime_attribute_on_item(
-                    &attribute.contents,
-                    item.clone(),
-                    span,
-                    attribute.contents_span,
-                    generated_items,
-                ) {
-                    self.errors.push(error);
-                }
-            }
+            self.run_comptime_attribute_on_item(attribute, &item, span, generated_items);
         }
     }
 
     fn run_comptime_attribute_on_item(
+        &mut self,
+        attribute: &SecondaryAttribute,
+        item: &Value,
+        span: Span,
+        generated_items: &mut CollectedItems,
+    ) {
+        if let SecondaryAttribute::Custom(attribute) = attribute {
+            if let Err(error) = self.run_comptime_attribute_name_on_item(
+                &attribute.contents,
+                item.clone(),
+                span,
+                attribute.contents_span,
+                generated_items,
+            ) {
+                self.errors.push(error);
+            }
+        }
+    }
+
+    fn run_comptime_attribute_name_on_item(
         &mut self,
         attribute: &str,
         item: Value,
@@ -383,7 +394,8 @@ impl<'context> Elaborator<'context> {
             | TopLevelStatement::Trait(_)
             | TopLevelStatement::Impl(_)
             | TopLevelStatement::TypeAlias(_)
-            | TopLevelStatement::SubModule(_) => {
+            | TopLevelStatement::SubModule(_)
+            | TopLevelStatement::InnerAttribute(_) => {
                 let item = item.to_string();
                 let error = InterpreterError::UnsupportedTopLevelItemUnquote { item, location };
                 self.errors.push(error.into_compilation_error_pair());
@@ -422,6 +434,7 @@ impl<'context> Elaborator<'context> {
         traits: &BTreeMap<TraitId, UnresolvedTrait>,
         types: &BTreeMap<StructId, UnresolvedStruct>,
         functions: &[UnresolvedFunctions],
+        module_attributes: &[ModuleAttribute],
     ) -> CollectedItems {
         let mut generated_items = CollectedItems::default();
 
@@ -444,9 +457,31 @@ impl<'context> Elaborator<'context> {
         }
 
         self.run_attributes_on_functions(functions, &mut generated_items);
+
+        self.run_attributes_on_modules(module_attributes, &mut generated_items);
+
         generated_items
     }
 
+    fn run_attributes_on_modules(
+        &mut self,
+        module_attributes: &[ModuleAttribute],
+        generated_items: &mut CollectedItems,
+    ) {
+        for module_attribute in module_attributes {
+            let local_id = module_attribute.module_id;
+            let module_id = ModuleId { krate: self.crate_id, local_id };
+            let item = Value::ModuleDefinition(module_id);
+            let attribute = &module_attribute.attribute;
+            let span = Span::default();
+
+            self.local_module = module_attribute.attribute_module_id;
+            self.file = module_attribute.attribute_file_id;
+
+            self.run_comptime_attribute_on_item(attribute, &item, span, generated_items);
+        }
+    }
+
     fn run_attributes_on_functions(
         &mut self,
         function_sets: &[UnresolvedFunctions],

compiler/noirc_frontend/src/elaborator/mod.rs

@@ -28,7 +28,7 @@
     node_interner::{
         DefinitionKind, DependencyId, ExprId, FuncId, GlobalId, ReferenceId, TraitId, TypeAliasId,
     },
     token::CustomAtrribute,
     Shared, Type, TypeVariable,
 };
 use crate::{
@@ -321,7 +321,12 @@
 
         // We have to run any comptime attributes on functions before the function is elaborated
         // since the generated items are checked beforehand as well.
-        let generated_items = self.run_attributes(&items.traits, &items.types, &items.functions);
+        let generated_items = self.run_attributes(
+            &items.traits,
+            &items.types,
+            &items.functions,
+            &items.module_attributes,
+        );
 
         // After everything is collected, we can elaborate our generated items.
         // It may be better to inline these within `items` entirely since elaborating them
@@ -820,7 +825,7 @@
         let attributes = func.secondary_attributes().iter();
         let attributes =
             attributes.filter_map(|secondary_attribute| secondary_attribute.as_custom());
         let attributes: Vec<CustomAtrribute> = attributes.cloned().collect();
 
         let meta = FuncMeta {
             name: name_ident,

compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs

@@ -108,6 +108,7 @@ impl<'local, 'context> Interpreter<'local, 'context> {
                 function_def_set_return_type(self, arguments, location)
             }
             "module_functions" => module_functions(self, arguments, location),
+            "module_has_named_attribute" => module_has_named_attribute(self, arguments, location),
             "module_is_contract" => module_is_contract(self, arguments, location),
             "module_name" => module_name(interner, arguments, location),
             "modulus_be_bits" => modulus_be_bits(interner, arguments, location),
@@ -1816,6 +1817,38 @@ fn module_functions(
     Ok(Value::Slice(func_ids, slice_type))
 }
 
+// fn has_named_attribute(self, name: Quoted) -> bool
+fn module_has_named_attribute(
+    interpreter: &Interpreter,
+    arguments: Vec<(Value, Location)>,
+    location: Location,
+) -> IResult<Value> {
+    let (self_argument, name) = check_two_arguments(arguments, location)?;
+    let module_id = get_module(self_argument)?;
+    let module_data = interpreter.elaborator.get_module(module_id);
+    let name = get_quoted(name)?;
+
+    let name = name.iter().map(|token| token.to_string()).collect::<Vec<_>>().join("");
+
+    let attributes = module_data.outer_attributes.iter().chain(&module_data.inner_attributes);
+    for attribute in attributes {
+        let parse_result = Elaborator::parse_attribute(attribute, location);
+        let Ok(Some((function, _arguments))) = parse_result else {
+            continue;
+        };
+
+        let ExpressionKind::Variable(path) = function.kind else {
+            continue;
+        };
+
+        if path.last_name() == name {
+            return Ok(Value::Bool(true));
+        }
+    }
+
+    Ok(Value::Bool(false))
+}
+
 // fn is_contract(self) -> bool
 fn module_is_contract(
     interpreter: &Interpreter,

compiler/noirc_frontend/src/hir/comptime/tests.rs

@@ -23,7 +23,13 @@ fn interpret_helper(src: &str) -> Result<Value, InterpreterError> {
     let module_id = LocalModuleId(Index::unsafe_zeroed());
     let mut modules = noirc_arena::Arena::default();
     let location = Location::new(Default::default(), file);
-    let root = LocalModuleId(modules.insert(ModuleData::new(None, location, false)));
+    let root = LocalModuleId(modules.insert(ModuleData::new(
+        None,
+        location,
+        Vec::new(),
+        Vec::new(),
+        false,
+    )));
     assert_eq!(root, module_id);
 
     let file_manager = FileManager::new(&PathBuf::new());

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

@@ -7,6 +7,7 @@ use crate::hir::def_map::{CrateDefMap, LocalModuleId, ModuleId};
 use crate::hir::resolution::errors::ResolverError;
 use crate::hir::resolution::path_resolver;
 use crate::hir::type_check::TypeCheckError;
+use crate::token::SecondaryAttribute;
 use crate::{Generics, Type};
 
 use crate::hir::resolution::import::{resolve_import, ImportDirective, PathResolution};
@@ -111,6 +112,21 @@ pub struct UnresolvedGlobal {
     pub stmt_def: LetStatement,
 }
 
+pub struct ModuleAttribute {
+    // The file in which the module is defined
+    pub file_id: FileId,
+    // The module this attribute is attached to
+    pub module_id: LocalModuleId,
+    // The file where the attribute exists (it could be the same as `file_id`
+    // or a different one if it's an inner attribute in a different file)
+    pub attribute_file_id: FileId,
+    // The module where the attribute is defined (similar to `attribute_file_id`,
+    // it could be different than `module_id` for inner attributes)
+    pub attribute_module_id: LocalModuleId,
+    pub attribute: SecondaryAttribute,
+    pub is_inner: bool,
+}
+
 /// Given a Crate root, collect all definitions in that crate
 pub struct DefCollector {
     pub(crate) def_map: CrateDefMap,
@@ -127,6 +143,7 @@ pub struct CollectedItems {
     pub globals: Vec<UnresolvedGlobal>,
     pub(crate) impls: ImplMap,
     pub(crate) trait_impls: Vec<UnresolvedTraitImpl>,
+    pub(crate) module_attributes: Vec<ModuleAttribute>,
 }
 
 impl CollectedItems {
@@ -238,6 +255,7 @@ impl DefCollector {
                 impls: HashMap::default(),
                 globals: vec![],
                 trait_impls: vec![],
+                module_attributes: vec![],
             },
         }
     }