feat(rust): add annotation support

Author: phodal

chapi-ast-rust/src/main/kotlin/chapi/ast/rustast/RustAstBaseListener.kt

@@ -1,6 +1,8 @@
 package chapi.ast.rustast
 
 import chapi.ast.antlr.RustParser
+import chapi.ast.antlr.RustParser.ItemContext
+import chapi.ast.antlr.RustParser.MacroIdentifierLikeTokenContext
 import chapi.ast.antlr.RustParser.TypePathSegmentContext
 import chapi.ast.antlr.RustParser.Type_Context
 import chapi.ast.antlr.RustParserBaseListener
@@ -72,26 +74,53 @@ open class RustAstBaseListener(private val fileName: String) : RustParserBaseLis
         Imports = imports
     }
 
-    fun buildPosition(ctx: ParserRuleContext): CodePosition {
-        val position = CodePosition()
-        position.StartLine = ctx.start.line
-        position.StartLinePosition = ctx.start.charPositionInLine
-        position.StopLine = ctx.stop.line
-        position.StopLinePosition = ctx.stop.charPositionInLine
-        return position
+    override fun enterOuterAttribute(ctx: RustParser.OuterAttributeContext?) {
+
     }
 
     override fun enterStructStruct(ctx: RustParser.StructStructContext?) {
-        val structName = ctx!!.identifier().text
+        val structName = ctx?.identifier()?.text ?: return
+
+        val item = ctx.parent?.parent?.parent
+        var annotation: MutableList<CodeAnnotation> = mutableListOf()
+        if (item is ItemContext) {
+            annotation = buildAttribute(item.outerAttribute())
+        }
 
         val codeStruct = CodeDataStruct(
             NodeName = structName,
-            Package = codeContainer.PackageName
+            Package = codeContainer.PackageName,
+            Annotations = annotation
         )
 
         structMap[structName] = codeStruct
     }
 
+    private fun buildAttribute(outerAttribute: List<RustParser.OuterAttributeContext>): MutableList<CodeAnnotation> {
+        return outerAttribute.map { attributeContext ->
+            val annotationName = attributeContext.attr()?.simplePath()?.simplePathSegment()?.filter { it.identifier() != null }?.map {
+                it.identifier().text
+            }?.joinToString(".") ?: ""
+
+            val keyValues = attributeContext.attr().attrInput().delimTokenTree().tokenTree()
+                .mapNotNull {
+                    it.tokenTreeToken()
+                        .mapNotNull { token -> token.macroIdentifierLikeToken() }
+                        .map { tokenContext ->
+                            AnnotationKeyValue(
+                                Key = tokenContext.identifier().text,
+                                Value = tokenContext.identifier().text
+                            )
+                        }
+                }.flatten()
+
+            CodeAnnotation(
+                Name = annotationName,
+                KeyValues = keyValues
+            )
+        }.toMutableList()
+    }
+
     override fun exitStructStruct(ctx: RustParser.StructStructContext?) {
 
     }
@@ -189,6 +218,15 @@ open class RustAstBaseListener(private val fileName: String) : RustParserBaseLis
         structMap[currentNode.NodeName] = currentNode
     }
 
+    private fun buildPosition(ctx: ParserRuleContext): CodePosition {
+        val position = CodePosition()
+        position.StartLine = ctx.start.line
+        position.StartLinePosition = ctx.start.charPositionInLine
+        position.StopLine = ctx.stop.line
+        position.StopLinePosition = ctx.stop.charPositionInLine
+        return position
+    }
+
     private fun buildDedicatedStructs(): List<CodeDataStruct> {
         if (individualFunctions.isEmpty() && individualFields.isEmpty()) return emptyList()
 

chapi-ast-rust/src/test/kotlin/chapi/ast/rustast/RustFullIdentListenerTest.kt

@@ -139,4 +139,26 @@ class RustFullIdentListenerTest {
         val functions = codeContainer.DataStructures[0].Functions
         assertEquals(2, functions.size)
     }
+
+    @Test
+    fun should_handle_for_attribute_as_annotation() {
+        val str = """
+            #[derive(Debug, Clone)]
+            pub struct EmbeddingMatch<Embedded: Clone + Ord> {
+                score: f32,
+                embedding_id: String,
+                embedding: Embedding,
+                embedded: Embedded,
+            }
+        """.trimIndent()
+
+        val codeContainer = RustAnalyser().analysis(str, "test.rs")
+        assertEquals(1, codeContainer.DataStructures[0].Annotations.size)
+
+        val codeAnnotation = codeContainer.DataStructures[0].Annotations[0]
+        assertEquals("derive", codeAnnotation.Name)
+        assertEquals(2, codeAnnotation.KeyValues.size)
+        assertEquals("Debug", codeAnnotation.KeyValues[0].Value)
+        assertEquals("Clone", codeAnnotation.KeyValues[1].Value)
+    }
 }

chapi-domain/src/main/kotlin/chapi/domain/core/CodeAnnotation.kt

@@ -5,6 +5,17 @@ import kotlinx.serialization.Serializable
 @Serializable
 data class AnnotationKeyValue(var Key: String = "", var Value: String = "")
 
+/**
+ * Represents a code annotation.
+ *
+ * In TypeScript, it is a decorator.
+ * In Rust, it is an attribute, like `#[derive(Debug, Clone)]`
+ * In Java/Kotlin/Scala, it is an annotation.
+ *
+ * @property Name The name of the annotation.
+ * @property KeyValues The list of key-value pairs associated with the annotation.
+ * @property Position The position of the annotation in the code.
+ */
 @Serializable
 data class CodeAnnotation(
     var Name: String = "",