Support parsing Luau function attributes (#337)

Supports the parsing of Luau function attributes, such as `@native` or
`@checked`. Does not perform any validation on the name of attributes,
unlike Luau.

Unfortunately, due to the existing `Attribute` struct for Lua 5.4
`<const>` attributes, we have to name the struct `LuauAttribute`.

**[BREAKING CHANGE]**: Because attributes can be attached to anonymous
functions, we create a new `AnonymousFunction` struct to handle this.
This replaces the old `Box<(TokenReference, FunctionBody)>`.

Closes #336

Author: JohnnyMorganz

CHANGELOG.md

@@ -13,7 +13,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   - In Unpacking e.g. `local a, b, c = t` is equivalent to `local a, b, c = t.a, t.b, t.c`
   - Set Constructors e.g. `t = { .x, .y }` is equivalent to `t = { x = true, y = true }`
   - C-Style Comments (single & multiline) e.g. `/* comment */`
-  - Compile Time Jenkins' Hashes e.g. ``` `Hello, World!` -> 1395890823``` 
+  - Compile Time Jenkins' Hashes e.g. ``` `Hello, World!` -> 1395890823```
+- Luau: support parsing function attributes (rfc: https://github.com/luau-lang/rfcs/blob/master/docs/syntax-attributes-functions.md)
+
+### Changed
+- **[BREAKING CHANGE]** Introduced a new struct `AnonymousFunction` that is used in the `Expression::Function` variant. The old `Box<(TokenReference, FunctionBody)>` is now replaced with `Box<AnonymousFunction>`, and allows us to attach more data to an anonymous function (at the moment, mainly Luau attributes)
 
 ## [1.2.0] - 2025-01-09
 

full-moon/src/ast/luau.rs

@@ -1205,3 +1205,42 @@ impl<'a> Iterator for ExpressionsIterator<'a> {
         Some(&segment.expression)
     }
 }
+
+/// An attribute, such as `@native`
+#[derive(Clone, Debug, Display, PartialEq, Node, Visit)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+#[display("{at_sign}{name}")]
+pub struct LuauAttribute {
+    pub(crate) at_sign: TokenReference,
+    pub(crate) name: TokenReference,
+}
+
+impl LuauAttribute {
+    /// Creates a new ElseIf from the given condition
+    pub fn new(name: TokenReference) -> Self {
+        Self {
+            at_sign: TokenReference::symbol("@").unwrap(),
+            name,
+        }
+    }
+
+    /// The `@` token
+    pub fn at_sign(&self) -> &TokenReference {
+        &self.at_sign
+    }
+
+    /// The name of the attribute, `native` in `@native`
+    pub fn name(&self) -> &TokenReference {
+        &self.name
+    }
+
+    /// Returns a new Attribute with the given `@` token
+    pub fn with_at_sign(self, at_sign: TokenReference) -> Self {
+        Self { at_sign, ..self }
+    }
+
+    /// Returns a new Attribute with the given name
+    pub fn with_name(self, name: TokenReference) -> Self {
+        Self { name, ..self }
+    }
+}

full-moon/src/ast/mod.rs

@@ -279,6 +279,74 @@ impl Default for TableConstructor {
     }
 }
 
+/// An anonymous function, such as `function() end`
+#[derive(Clone, Debug, Display, PartialEq, Node, Visit)]
+#[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
+#[cfg_attr(not(feature = "luau"), display("{function_token}{body}"))]
+#[cfg_attr(
+    feature = "luau",
+    display("{}{}{}", join_vec(attributes), function_token, body)
+)]
+pub struct AnonymousFunction {
+    #[cfg(feature = "luau")]
+    attributes: Vec<LuauAttribute>,
+    function_token: TokenReference,
+    body: FunctionBody,
+}
+
+impl AnonymousFunction {
+    /// Returns a new AnonymousFunction
+    pub fn new() -> Self {
+        AnonymousFunction {
+            #[cfg(feature = "luau")]
+            attributes: Vec::new(),
+            function_token: TokenReference::basic_symbol("function"),
+            body: FunctionBody::new(),
+        }
+    }
+
+    /// The attributes in the function, e.g. `@native`
+    #[cfg(feature = "luau")]
+    pub fn attributes(&self) -> impl Iterator<Item = &LuauAttribute> {
+        self.attributes.iter()
+    }
+
+    /// The `function` token
+    pub fn function_token(&self) -> &TokenReference {
+        &self.function_token
+    }
+
+    /// The function body, everything except `function` in `function(a, b, c) call() end`
+    pub fn body(&self) -> &FunctionBody {
+        &self.body
+    }
+
+    /// Returns a new AnonymousFunction with the given attributes (e.g. `@native`)
+    #[cfg(feature = "luau")]
+    pub fn with_attributes(self, attributes: Vec<LuauAttribute>) -> Self {
+        Self { attributes, ..self }
+    }
+
+    /// Returns a new AnonymousFunction with the given `function` token
+    pub fn with_function_token(self, function_token: TokenReference) -> Self {
+        Self {
+            function_token,
+            ..self
+        }
+    }
+
+    /// Returns a new AnonymousFunction with the given function body
+    pub fn with_body(self, body: FunctionBody) -> Self {
+        Self { body, ..self }
+    }
+}
+
+impl Default for AnonymousFunction {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 /// An expression, mostly useful for getting values
 #[derive(Clone, Debug, Display, PartialEq, Node)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
@@ -315,8 +383,8 @@ pub enum Expression {
     },
 
     /// An anonymous function, such as `function() end`
-    #[display("{}{}", _0.0, _0.1)]
-    Function(Box<(TokenReference, FunctionBody)>),
+    #[display("{_0}")]
+    Function(Box<AnonymousFunction>),
 
     /// A call of a function, such as `call()`
     #[display("{_0}")]
@@ -1620,8 +1688,20 @@ impl Assignment {
     not(feature = "luau"),
     display("{local_token}{function_token}{name}{body}")
 )]
-#[cfg_attr(feature = "luau", display("{local_token}{function_token}{name}{body}"))]
+#[cfg_attr(
+    feature = "luau",
+    display(
+        "{}{}{}{}{}",
+        join_vec(attributes),
+        local_token,
+        function_token,
+        name,
+        body
+    )
+)]
 pub struct LocalFunction {
+    #[cfg(feature = "luau")]
+    attributes: Vec<LuauAttribute>,
     local_token: TokenReference,
     function_token: TokenReference,
     name: TokenReference,
@@ -1632,13 +1712,21 @@ impl LocalFunction {
     /// Returns a new LocalFunction from the given name
     pub fn new(name: TokenReference) -> Self {
         LocalFunction {
+            #[cfg(feature = "luau")]
+            attributes: Vec::new(),
             local_token: TokenReference::basic_symbol("local "),
             function_token: TokenReference::basic_symbol("function "),
             name,
             body: FunctionBody::new(),
         }
     }
 
+    /// The attributes in the function, e.g. `@native`
+    #[cfg(feature = "luau")]
+    pub fn attributes(&self) -> impl Iterator<Item = &LuauAttribute> {
+        self.attributes.iter()
+    }
+
     /// The `local` token
     pub fn local_token(&self) -> &TokenReference {
         &self.local_token
@@ -1659,6 +1747,12 @@ impl LocalFunction {
         &self.name
     }
 
+    /// Returns a new LocalFunction with the given attributes (e.g. `@native`)
+    #[cfg(feature = "luau")]
+    pub fn with_attributes(self, attributes: Vec<LuauAttribute>) -> Self {
+        Self { attributes, ..self }
+    }
+
     /// Returns a new LocalFunction with the given `local` token
     pub fn with_local_token(self, local_token: TokenReference) -> Self {
         Self {
@@ -1992,8 +2086,13 @@ impl FunctionName {
 #[derive(Clone, Debug, Display, PartialEq, Node, Visit)]
 #[cfg_attr(feature = "serde", derive(Deserialize, Serialize))]
 #[cfg_attr(not(feature = "luau"), display("{function_token}{name}{body}"))]
-#[cfg_attr(feature = "luau", display("{function_token}{name}{body}"))]
+#[cfg_attr(
+    feature = "luau",
+    display("{}{}{}{}", join_vec(attributes), function_token, name, body)
+)]
 pub struct FunctionDeclaration {
+    #[cfg(feature = "luau")]
+    attributes: Vec<LuauAttribute>,
     function_token: TokenReference,
     name: FunctionName,
     body: FunctionBody,
@@ -2003,12 +2102,20 @@ impl FunctionDeclaration {
     /// Creates a new FunctionDeclaration from the given name
     pub fn new(name: FunctionName) -> Self {
         Self {
+            #[cfg(feature = "luau")]
+            attributes: Vec::new(),
             function_token: TokenReference::basic_symbol("function "),
             name,
             body: FunctionBody::new(),
         }
     }
 
+    /// The attributes in the function, e.g. `@native`
+    #[cfg(feature = "luau")]
+    pub fn attributes(&self) -> impl Iterator<Item = &LuauAttribute> {
+        self.attributes.iter()
+    }
+
     /// The `function` token
     pub fn function_token(&self) -> &TokenReference {
         &self.function_token
@@ -2024,6 +2131,12 @@ impl FunctionDeclaration {
         &self.name
     }
 
+    /// Returns a new FunctionDeclaration with the given attributes (e.g. `@native`)
+    #[cfg(feature = "luau")]
+    pub fn with_attributes(self, attributes: Vec<LuauAttribute>) -> Self {
+        Self { attributes, ..self }
+    }
+
     /// Returns a new FunctionDeclaration with the given `function` token
     pub fn with_function_token(self, function_token: TokenReference) -> Self {
         Self {