plugin docstring parsing now respect @param, @retunm, @throws and general support for such tags introduced

lynglib/src/commonMain/kotlin/net/sergeych/lyng/Compiler.kt

@@ -116,10 +116,8 @@ class Compiler(
 
     private fun consumePendingDoc(): MiniDoc? {
         if (pendingDocLines.isEmpty()) return null
-        val raw = pendingDocLines.joinToString("\n").trimEnd()
-        val summary = raw.lines().firstOrNull { it.isNotBlank() }?.trim()
         val start = pendingDocStart ?: cc.currentPos()
-        val doc = MiniDoc(MiniRange(start, start), raw = raw, summary = summary)
+        val doc = MiniDoc.parse(MiniRange(start, start), pendingDocLines)
         clearPendingDoc()
         return doc
     }

lynglib/src/commonMain/kotlin/net/sergeych/lyng/miniast/BuiltinDocRegistry.kt

@@ -255,8 +255,7 @@ class ClassDocsBuilder internal constructor(private val className: String) {
 private fun builtinRange() = MiniRange(Pos.builtIn, Pos.builtIn)
 
 private fun miniDoc(text: String, tags: Map<String, List<String>>): MiniDoc {
-    val summary = text.lineSequence().map { it.trim() }.firstOrNull { it.isNotEmpty() }
-    return MiniDoc(range = builtinRange(), raw = text, summary = summary, tags = tags)
+    return MiniDoc.parse(builtinRange(), listOf(text), tags)
 }
 
 private fun TypeDoc.toDisplayName(): String = when (this) {

lynglib/src/commonMain/kotlin/net/sergeych/lyng/miniast/MiniAst.kt

@@ -39,7 +39,56 @@ data class MiniDoc(
     val raw: String,
     val summary: String?,
     val tags: Map<String, List<String>> = emptyMap()
-)
+) {
+    companion object {
+        fun parse(range: MiniRange, lines: Iterable<String>, extraTags: Map<String, List<String>> = emptyMap()): MiniDoc {
+            val parsedTags = mutableMapOf<String, MutableList<String>>()
+            var currentTag: String? = null
+            val currentContent = StringBuilder()
+
+            fun flush() {
+                currentTag?.let { tag ->
+                    parsedTags.getOrPut(tag) { mutableListOf() }.add(currentContent.toString().trim())
+                }
+                currentContent.setLength(0)
+            }
+
+            val descriptionLines = mutableListOf<String>()
+            var inTags = false
+
+            for (rawLine in lines) {
+                for (line in rawLine.lines()) {
+                    val trimmed = line.trim()
+                    if (trimmed.startsWith("@")) {
+                        inTags = true
+                        flush()
+                        val parts = trimmed.substring(1).split(Regex("\\s+"), 2)
+                        currentTag = parts[0]
+                        currentContent.append(parts.getOrNull(1) ?: "")
+                    } else {
+                        if (inTags) {
+                            if (currentContent.isNotEmpty()) currentContent.append("\n")
+                            currentContent.append(line)
+                        } else {
+                            descriptionLines.add(line)
+                        }
+                    }
+                }
+            }
+            flush()
+
+            val raw = descriptionLines.joinToString("\n").trimEnd()
+            val summary = raw.lines().firstOrNull { it.isNotBlank() }?.trim()
+            
+            val finalTags = parsedTags.toMutableMap()
+            extraTags.forEach { (k, v) ->
+                finalTags.getOrPut(k) { mutableListOf() }.addAll(v)
+            }
+            
+            return MiniDoc(range, raw, summary, finalTags)
+        }
+    }
+}
 
 sealed interface MiniNode { val range: MiniRange }