feat(rust): init basic documentation

Author: phodal

java/src/main/kotlin/cc/unitmesh/idea/provider/JavaLivingDocumentation.kt

@@ -75,10 +75,6 @@ class JavaLivingDocumentation : LivingDocumentation {
 
     }
 
-    private fun containsElement(selectionModel: SelectionModel, element: PsiElement): Boolean {
-        return selectionModel.selectionStart <= element.textRange.startOffset && element.textRange.endOffset <= selectionModel.selectionEnd
-    }
-
     override fun findDocTargetsInSelection(
         root: PsiElement,
         selectionModel: SelectionModel,

kotlin/src/main/kotlin/cc/unitmesh/kotlin/provider/KotlinLivingDocumentation.kt

@@ -137,10 +137,6 @@ class KotlinLivingDocumentation : LivingDocumentation {
         })
     }
 
-    private fun containsElement(selectionModel: SelectionModel, element: PsiElement): Boolean {
-        return selectionModel.selectionStart <= element.textRange.startOffset && element.textRange.endOffset <= selectionModel.selectionEnd
-    }
-
     override fun findDocTargetsInSelection(
         root: PsiElement,
         selectionModel: SelectionModel,

rust/src/main/kotlin/cc/unitmesh/rust/context/RustClassContextBuilder.kt

@@ -6,20 +6,25 @@ import com.intellij.psi.PsiElement
 import org.rust.lang.core.psi.RsEnumItem
 import org.rust.lang.core.psi.RsStructItem
 import org.rust.lang.core.psi.ext.RsStructOrEnumItemElement
+import org.rust.lang.core.psi.ext.fields
 
 class RustClassContextBuilder : ClassContextBuilder {
     override fun getClassContext(psiElement: PsiElement, gatherUsages: Boolean): ClassContext? {
         if (psiElement !is RsStructOrEnumItemElement) return null
         when (psiElement) {
             is RsStructItem -> {
+                val fields: List<PsiElement> = psiElement.fields.map {
+                    it.typeReference?.reference?.resolve() ?: it
+                }
                 return ClassContext(
                     psiElement,
                     psiElement.text,
                     psiElement.name,
                     emptyList(),
+                    fields,
                     emptyList(),
                     emptyList(),
-                    emptyList()
+                    psiElement.name
                 )
             }
 

rust/src/main/kotlin/cc/unitmesh/rust/provider/RustLivingDocumentation.kt

@@ -0,0 +1,75 @@
+package cc.unitmesh.rust.provider
+
+import cc.unitmesh.devti.custom.document.LivingDocumentationType
+import cc.unitmesh.devti.provider.LivingDocumentation
+import com.intellij.codeInsight.daemon.impl.CollectHighlightsUtil
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.editor.SelectionModel
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiNameIdentifierOwner
+import com.intellij.psi.util.PsiTreeUtil
+import org.rust.lang.core.psi.RsFunction
+import org.rust.lang.core.psi.ext.RsNameIdentifierOwner
+import org.rust.lang.core.psi.ext.RsStructOrEnumItemElement
+
+class RustLivingDocumentation : LivingDocumentation {
+    override val forbiddenRules: List<String>
+        get() = listOf()
+
+    override fun startEndString(type: LivingDocumentationType): Pair<String, String> {
+        return Pair("///", "///")
+    }
+
+    override fun updateDoc(target: PsiElement, newDoc: String, type: LivingDocumentationType, editor: Editor) {
+        val project = target.project
+        val file = target.containingFile
+        val startOffset = target.textRange.startOffset
+        val newEndOffset = startOffset + newDoc.length
+
+        editor.document.insertString(startOffset, newDoc)
+        val codeStyleManager = com.intellij.psi.codeStyle.CodeStyleManager.getInstance(project)
+        codeStyleManager.reformatText(file, startOffset, newEndOffset)
+    }
+
+    override fun findNearestDocumentationTarget(psiElement: PsiElement): PsiNameIdentifierOwner? {
+        if (psiElement is RsNameIdentifierOwner) return psiElement
+
+        val closestIdentifierOwner = PsiTreeUtil.getParentOfType(psiElement, PsiNameIdentifierOwner::class.java)
+        if (closestIdentifierOwner !is RsFunction) {
+            return PsiTreeUtil.getParentOfType(psiElement, RsFunction::class.java) ?: closestIdentifierOwner
+        }
+
+        return closestIdentifierOwner
+    }
+
+    override fun findDocTargetsInSelection(
+        root: PsiElement,
+        selectionModel: SelectionModel
+    ): List<PsiNameIdentifierOwner> {
+        val commonParent: PsiElement? =
+            CollectHighlightsUtil.findCommonParent(root, selectionModel.selectionStart, selectionModel.selectionEnd)
+
+        if (commonParent is RsStructOrEnumItemElement) {
+            return listOf(commonParent)
+        }
+
+        val nearestDocumentationTarget = findNearestDocumentationTarget(commonParent!!)
+        if (nearestDocumentationTarget !is RsFunction ||
+            containsElement(selectionModel, nearestDocumentationTarget)
+        ) {
+            return listOf(nearestDocumentationTarget!!)
+        }
+
+        val classDeclarations = nearestDocumentationTarget.children
+        return filterAndCollectNameIdentifierOwners(classDeclarations, selectionModel)
+    }
+
+    private fun filterAndCollectNameIdentifierOwners(
+        declarations: Array<PsiElement>,
+        selectionModel: SelectionModel,
+    ): List<PsiNameIdentifierOwner> {
+        val filteredElements = declarations.filterIsInstance<PsiNameIdentifierOwner>()
+            .filter { containsElement(selectionModel, it) }
+        return filteredElements.toList()
+    }
+}

rust/src/main/resources/cc.unitmesh.rust.xml

@@ -16,5 +16,9 @@
         <contextPrompter language="Rust" implementation="cc.unitmesh.rust.provider.RustContextPrompter"/>
 
         <chatContextProvider implementation="cc.unitmesh.rust.provider.RustContextProvider"/>
+
+        <livingDocumentation language="Rust"
+                             implementationClass="cc.unitmesh.rust.provider.RustLivingDocumentation"/>
+
     </extensions>
 </idea-plugin>

src/main/kotlin/cc/unitmesh/devti/provider/LivingDocumentation.kt

@@ -27,6 +27,9 @@ interface LivingDocumentation {
     fun findNearestDocumentationTarget(psiElement: PsiElement): PsiNameIdentifierOwner?
 
     fun findDocTargetsInSelection(root: PsiElement, selectionModel: SelectionModel): List<PsiNameIdentifierOwner>
+    fun containsElement(selectionModel: SelectionModel, element: PsiElement): Boolean {
+        return selectionModel.selectionStart <= element.textRange.startOffset && element.textRange.endOffset <= selectionModel.selectionEnd
+    }
 
     companion object {
         private val languageExtension: LanguageExtension<LivingDocumentation> =