diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs index d7632eda2ce..9d1349b5209 100644 --- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs +++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin.rs @@ -441,7 +441,7 @@ fn struct_def_eq(arguments: Vec<(Value, Location)>, location: Location) -> IResu eq_item(arguments, location, get_struct) } -// fn has_named_attribute(self, name: Quoted) -> bool +// fn has_named_attribute(self, name: str) -> bool {} fn struct_def_has_named_attribute( interner: &NodeInterner, arguments: Vec<(Value, Location)>, @@ -450,14 +450,9 @@ fn struct_def_has_named_attribute( let (self_argument, name) = check_two_arguments(arguments, location)?; let struct_id = get_struct(self_argument)?; - let name = get_quoted(name)?; - let name = name.iter().map(|token| token.to_string()).collect::>().join(""); + let name = get_str(interner, name)?; - let attributes = interner.struct_attributes(&struct_id); - let attributes = attributes.iter().filter_map(|attribute| attribute.as_custom()); - let attributes = attributes.map(|attribute| &attribute.contents); - - Ok(Value::Bool(has_named_attribute(&name, attributes, location))) + Ok(Value::Bool(has_named_attribute(&name, interner.struct_attributes(&struct_id)))) } /// fn fields(self) -> [(Quoted, Type)] @@ -1957,7 +1952,7 @@ fn function_def_body( } } -// fn has_named_attribute(self, name: Quoted) -> bool +// fn has_named_attribute(self, name: str) -> bool {} fn function_def_has_named_attribute( interner: &NodeInterner, arguments: Vec<(Value, Location)>, @@ -1965,15 +1960,17 @@ fn function_def_has_named_attribute( ) -> IResult { let (self_argument, name) = check_two_arguments(arguments, location)?; let func_id = get_function_def(self_argument)?; - let func_meta = interner.function_meta(&func_id); - let name = get_quoted(name)?; - let name = name.iter().map(|token| token.to_string()).collect::>().join(""); + let name = &*get_str(interner, name)?; - let attributes = &func_meta.custom_attributes; - let attributes = attributes.iter().map(|attribute| &attribute.contents); + let modifiers = interner.function_modifiers(&func_id); + if let Some(attribute) = &modifiers.attributes.function { + if name == attribute.name() { + return Ok(Value::Bool(true)); + } + } - Ok(Value::Bool(has_named_attribute(&name, attributes, location))) + Ok(Value::Bool(has_named_attribute(name, &modifiers.attributes.secondary))) } fn function_def_hash(arguments: Vec<(Value, Location)>, location: Location) -> IResult { @@ -2306,7 +2303,7 @@ fn module_structs( Ok(Value::Slice(struct_ids, slice_type)) } -// fn has_named_attribute(self, name: Quoted) -> bool +// fn has_named_attribute(self, name: str) -> bool {} fn module_has_named_attribute( interpreter: &Interpreter, arguments: Vec<(Value, Location)>, @@ -2316,12 +2313,9 @@ fn module_has_named_attribute( 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::>().join(""); - - let attributes = module_data.outer_attributes.iter().chain(&module_data.inner_attributes); + let name = get_str(interpreter.elaborator.interner, name)?; - Ok(Value::Bool(has_named_attribute(&name, attributes, location))) + Ok(Value::Bool(has_named_attribute(&name, &module_data.attributes))) } // fn is_contract(self) -> bool diff --git a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs index e50bb14b2d6..911e89a52ec 100644 --- a/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs +++ b/compiler/noirc_frontend/src/hir/comptime/interpreter/builtin/builtin_helpers.rs @@ -9,7 +9,6 @@ use crate::{ BlockExpression, ExpressionKind, IntegerBitSize, LValue, Pattern, Signedness, StatementKind, UnresolvedTypeData, }, - elaborator::Elaborator, hir::{ comptime::{ errors::IResult, @@ -26,7 +25,7 @@ use crate::{ macros_api::{NodeInterner, StructId}, node_interner::{FuncId, TraitId, TraitImplId}, parser::NoirParser, - token::{Token, Tokens}, + token::{SecondaryAttribute, Token, Tokens}, QuotedType, Type, }; @@ -450,23 +449,12 @@ pub(super) fn block_expression_to_value(block_expr: BlockExpression) -> Value { Value::Slice(statements, typ) } -pub(super) fn has_named_attribute<'a>( - name: &'a str, - attributes: impl Iterator, - location: Location, -) -> bool { +pub(super) fn has_named_attribute(name: &str, attributes: &[SecondaryAttribute]) -> bool { 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 true; + if let Some(attribute_name) = attribute.name() { + if name == attribute_name { + return true; + } } } diff --git a/compiler/noirc_frontend/src/hir/def_map/module_data.rs b/compiler/noirc_frontend/src/hir/def_map/module_data.rs index e829df3572c..6a0f472ef75 100644 --- a/compiler/noirc_frontend/src/hir/def_map/module_data.rs +++ b/compiler/noirc_frontend/src/hir/def_map/module_data.rs @@ -26,8 +26,7 @@ pub struct ModuleData { /// True if this module is a `contract Foo { ... }` module containing contract functions pub is_contract: bool, - pub outer_attributes: Vec, - pub inner_attributes: Vec, + pub attributes: Vec, } impl ModuleData { @@ -38,11 +37,8 @@ impl ModuleData { inner_attributes: Vec, is_contract: bool, ) -> ModuleData { - let outer_attributes = outer_attributes.iter().filter_map(|attr| attr.as_custom()); - let outer_attributes = outer_attributes.map(|attr| attr.contents.to_string()).collect(); - - let inner_attributes = inner_attributes.iter().filter_map(|attr| attr.as_custom()); - let inner_attributes = inner_attributes.map(|attr| attr.contents.to_string()).collect(); + let mut attributes = outer_attributes; + attributes.extend(inner_attributes); ModuleData { parent, @@ -51,8 +47,7 @@ impl ModuleData { definitions: ItemScope::default(), location, is_contract, - outer_attributes, - inner_attributes, + attributes, } } diff --git a/compiler/noirc_frontend/src/lexer/token.rs b/compiler/noirc_frontend/src/lexer/token.rs index 3b615e91f8f..012b21a8904 100644 --- a/compiler/noirc_frontend/src/lexer/token.rs +++ b/compiler/noirc_frontend/src/lexer/token.rs @@ -10,6 +10,8 @@ use crate::{ }, }; +use super::Lexer; + /// Represents a token in noir's grammar - a word, number, /// or symbol that can be used in noir's syntax. This is the /// smallest unit of grammar. A parser may (will) decide to parse @@ -868,6 +870,18 @@ impl FunctionAttribute { pub fn is_no_predicates(&self) -> bool { matches!(self, FunctionAttribute::NoPredicates) } + + pub fn name(&self) -> &'static str { + match self { + FunctionAttribute::Foreign(_) => "foreign", + FunctionAttribute::Builtin(_) => "builtin", + FunctionAttribute::Oracle(_) => "oracle", + FunctionAttribute::Test(_) => "test", + FunctionAttribute::Recursive => "recursive", + FunctionAttribute::Fold => "fold", + FunctionAttribute::NoPredicates => "no_predicates", + } + } } impl fmt::Display for FunctionAttribute { @@ -903,15 +917,6 @@ pub enum SecondaryAttribute { Varargs, } -#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)] -pub struct CustomAtrribute { - pub contents: String, - // The span of the entire attribute, including leading `#[` and trailing `]` - pub span: Span, - // The span for the attribute contents (what's inside `#[...]`) - pub contents_span: Span, -} - impl SecondaryAttribute { pub(crate) fn as_custom(&self) -> Option<&CustomAtrribute> { if let Self::Custom(attribute) = self { @@ -920,6 +925,20 @@ impl SecondaryAttribute { None } } + + pub(crate) fn name(&self) -> Option { + match self { + SecondaryAttribute::Deprecated(_) => Some("deprecated".to_string()), + SecondaryAttribute::ContractLibraryMethod => { + Some("contract_library_method".to_string()) + } + SecondaryAttribute::Export => Some("export".to_string()), + SecondaryAttribute::Field(_) => Some("field".to_string()), + SecondaryAttribute::Custom(custom) => custom.name(), + SecondaryAttribute::Abi(_) => Some("abi".to_string()), + SecondaryAttribute::Varargs => Some("varargs".to_string()), + } + } } impl fmt::Display for SecondaryAttribute { @@ -939,6 +958,27 @@ impl fmt::Display for SecondaryAttribute { } } +#[derive(PartialEq, Eq, Hash, Debug, Clone, PartialOrd, Ord)] +pub struct CustomAtrribute { + pub contents: String, + // The span of the entire attribute, including leading `#[` and trailing `]` + pub span: Span, + // The span for the attribute contents (what's inside `#[...]`) + pub contents_span: Span, +} + +impl CustomAtrribute { + fn name(&self) -> Option { + let mut lexer = Lexer::new(&self.contents); + let token = lexer.next()?.ok()?; + if let Token::Ident(ident) = token.into_token() { + Some(ident) + } else { + None + } + } +} + impl AsRef for FunctionAttribute { fn as_ref(&self) -> &str { match self { diff --git a/noir_stdlib/src/meta/function_def.nr b/noir_stdlib/src/meta/function_def.nr index 6c68978a630..cd5f9cc79fb 100644 --- a/noir_stdlib/src/meta/function_def.nr +++ b/noir_stdlib/src/meta/function_def.nr @@ -11,7 +11,7 @@ impl FunctionDefinition { #[builtin(function_def_has_named_attribute)] // docs:start:has_named_attribute - comptime fn has_named_attribute(self, name: Quoted) -> bool {} + comptime fn has_named_attribute(self, name: str) -> bool {} // docs:end:has_named_attribute #[builtin(function_def_is_unconstrained)] diff --git a/noir_stdlib/src/meta/module.nr b/noir_stdlib/src/meta/module.nr index d983b8e3a8c..1b29301c4ef 100644 --- a/noir_stdlib/src/meta/module.nr +++ b/noir_stdlib/src/meta/module.nr @@ -6,7 +6,7 @@ impl Module { #[builtin(module_has_named_attribute)] // docs:start:has_named_attribute - comptime fn has_named_attribute(self, name: Quoted) -> bool {} + comptime fn has_named_attribute(self, name: str) -> bool {} // docs:end:has_named_attribute #[builtin(module_is_contract)] diff --git a/noir_stdlib/src/meta/struct_def.nr b/noir_stdlib/src/meta/struct_def.nr index 064891fda3f..b17c0d37613 100644 --- a/noir_stdlib/src/meta/struct_def.nr +++ b/noir_stdlib/src/meta/struct_def.nr @@ -18,7 +18,7 @@ impl StructDefinition { #[builtin(struct_def_has_named_attribute)] // docs:start:has_named_attribute - comptime fn has_named_attribute(self, name: Quoted) -> bool {} + comptime fn has_named_attribute(self, name: str) -> bool {} // docs:end:has_named_attribute /// Return each generic on this struct. diff --git a/test_programs/compile_success_empty/attributes_struct/src/main.nr b/test_programs/compile_success_empty/attributes_struct/src/main.nr index 79bf3e29533..669cfc32927 100644 --- a/test_programs/compile_success_empty/attributes_struct/src/main.nr +++ b/test_programs/compile_success_empty/attributes_struct/src/main.nr @@ -9,13 +9,16 @@ fn main() {} // Check that add_attribute and has_named_attribute work well +#[abi(something)] #[add_attribute] struct Foo { } comptime fn add_attribute(s: StructDefinition) { - assert(!s.has_named_attribute(quote { foo })); + assert(!s.has_named_attribute("foo")); s.add_attribute("foo"); - assert(s.has_named_attribute(quote { foo })); + assert(s.has_named_attribute("foo")); + + assert(s.has_named_attribute("abi")); } 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 e01ff4a71f1..4266d3734f9 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 @@ -8,6 +8,11 @@ pub fn foo(w: i32, y: Field, Foo { x, field: some_field }: Foo, mut a: bool, (b, 1 } +#[test] +#[deprecated] +#[check_named_attribute] +fn some_test() {} + comptime fn function_attr(f: FunctionDefinition) { // Check FunctionDefinition::parameters let parameters = f.parameters(); @@ -33,7 +38,12 @@ comptime fn function_attr(f: FunctionDefinition) { // Check FunctionDefinition::name assert_eq(f.name(), quote { foo }); - assert(f.has_named_attribute(quote { function_attr })); + assert(f.has_named_attribute("function_attr")); +} + +comptime fn check_named_attribute(f: FunctionDefinition) { + assert(f.has_named_attribute("test")); + assert(f.has_named_attribute("deprecated")); } #[mutate_add_one] diff --git a/test_programs/compile_success_empty/comptime_module/src/main.nr b/test_programs/compile_success_empty/comptime_module/src/main.nr index 21296cce056..9443b59fb0a 100644 --- a/test_programs/compile_success_empty/comptime_module/src/main.nr +++ b/test_programs/compile_success_empty/comptime_module/src/main.nr @@ -85,10 +85,10 @@ fn main() { assert_eq(bar.name(), quote { bar }); // Check Module::has_named_attribute - assert(foo.has_named_attribute(quote { some_attribute })); - assert(foo.has_named_attribute(quote { outer_attribute })); - assert(!bar.has_named_attribute(quote { some_attribute })); - assert(another_module.has_named_attribute(quote { some_attribute })); + assert(foo.has_named_attribute("some_attribute")); + assert(foo.has_named_attribute("outer_attribute")); + assert(!bar.has_named_attribute("some_attribute")); + assert(another_module.has_named_attribute("some_attribute")); } assert_eq(counter, 4); diff --git a/test_programs/compile_success_empty/inject_context_attribute/src/main.nr b/test_programs/compile_success_empty/inject_context_attribute/src/main.nr index 9dc8cf1ed47..156579ce0b2 100644 --- a/test_programs/compile_success_empty/inject_context_attribute/src/main.nr +++ b/test_programs/compile_success_empty/inject_context_attribute/src/main.nr @@ -45,7 +45,7 @@ comptime fn mapping_function(expr: Expr, f: FunctionDefinition) -> Option let (name, arguments) = func_call; name.resolve(Option::some(f)).as_function_definition().and_then( |function_definition: FunctionDefinition| { - if function_definition.has_named_attribute(quote { inject_context }) { + if function_definition.has_named_attribute("inject_context") { let arguments = arguments.push_front(quote { _context }.as_expr().unwrap()); let arguments = arguments.map(|arg: Expr| arg.quoted()).join(quote { , }); Option::some(quote { $name($arguments) }.as_expr().unwrap())