feat: Add refactoring

Author: GlebMikhailov

.claude/settings.local.json

@@ -14,7 +14,10 @@
       "Bash(xargs cat:*)",
       "Bash(JAVA_HOME=/Users/glebmikhailov/Library/Java/JavaVirtualMachines/corretto-17.0.10/Contents/Home ./gradlew clean build:*)",
       "Bash(JAVA_HOME=/Users/glebmikhailov/Library/Java/JavaVirtualMachines/corretto-17.0.10/Contents/Home ./gradlew clean compileKotlin:*)",
-      "Bash(git stash:*)"
+      "Bash(git stash:*)",
+      "Bash(/usr/libexec/java_home:*)",
+      "Bash(JAVA_HOME=/Users/glebmikhailov/Library/Java/JavaVirtualMachines/corretto-17.0.10/Contents/Home ./gradlew compileKotlin:*)",
+      "Bash(JAVA_HOME=/Users/glebmikhailov/Library/Java/JavaVirtualMachines/corretto-17.0.10/Contents/Home ./gradlew buildPlugin:*)"
     ]
   }
 }

src/main/kotlin/org/rhai/refactoring/RhaiNamesValidator.kt

@@ -0,0 +1,33 @@
+package org.rhai.refactoring
+
+import com.intellij.lang.refactoring.NamesValidator
+import com.intellij.openapi.project.Project
+
+/**
+ * Validates identifier names in Rhai.
+ * Used by rename refactoring to check if new names are valid.
+ */
+class RhaiNamesValidator : NamesValidator {
+
+    private val keywords = setOf(
+        "let", "const", "fn", "if", "else", "while", "for", "in",
+        "loop", "break", "continue", "return", "throw", "try", "catch",
+        "switch", "default", "import", "export", "module", "private", "pub",
+        "true", "false", "null", "this", "global", "is", "as", "do", "until",
+        "shared", "sync", "async", "await", "inf", "NaN", "undefined"
+    )
+
+    override fun isKeyword(name: String, project: Project?): Boolean {
+        return keywords.contains(name)
+    }
+
+    override fun isIdentifier(name: String, project: Project?): Boolean {
+        if (name.isEmpty()) return false
+
+        // Rhai identifiers: start with letter or underscore, followed by letters, digits, or underscores
+        val firstChar = name[0]
+        if (!firstChar.isLetter() && firstChar != '_') return false
+
+        return name.all { it.isLetterOrDigit() || it == '_' }
+    }
+}

src/main/kotlin/org/rhai/refactoring/RhaiPsiFactory.kt

@@ -0,0 +1,40 @@
+package org.rhai.refactoring
+
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFileFactory
+import com.intellij.psi.util.PsiTreeUtil
+import org.rhai.RhaiLetDeclaration
+import org.rhai.RhaiTypes
+import org.rhai.lang.RhaiFile
+import org.rhai.lang.RhaiFileType
+
+/**
+ * Factory for creating Rhai PSI elements.
+ * Used by refactoring operations to create new elements.
+ */
+class RhaiPsiFactory(private val project: Project) {
+
+    /**
+     * Create an identifier element with the given name.
+     */
+    fun createIdentifier(name: String): PsiElement {
+        // Create a simple let declaration to extract the identifier
+        val file = createFile("let $name = 0;")
+        val letDecl = PsiTreeUtil.findChildOfType(file, RhaiLetDeclaration::class.java)
+            ?: throw IllegalStateException("Failed to create identifier PSI element")
+
+        val identifierNode = letDecl.pattern.node.findChildByType(RhaiTypes.IDENTIFIER)
+            ?: throw IllegalStateException("Failed to find identifier in created element")
+
+        return identifierNode.psi
+    }
+
+    /**
+     * Create a Rhai file with the given content.
+     */
+    fun createFile(content: String): RhaiFile {
+        return PsiFileFactory.getInstance(project)
+            .createFileFromText("dummy.rhai", RhaiFileType.INSTANCE, content) as RhaiFile
+    }
+}

src/main/kotlin/org/rhai/refactoring/RhaiRenameHandler.kt

@@ -0,0 +1,87 @@
+package org.rhai.refactoring
+
+import com.intellij.openapi.actionSystem.CommonDataKeys
+import com.intellij.openapi.actionSystem.DataContext
+import com.intellij.openapi.editor.Editor
+import com.intellij.openapi.project.Project
+import com.intellij.psi.PsiElement
+import com.intellij.psi.PsiFile
+import com.intellij.psi.util.elementType
+import com.intellij.refactoring.rename.PsiElementRenameHandler
+import com.intellij.refactoring.rename.RenameHandler
+import org.rhai.RhaiTypes
+import org.rhai.lang.RhaiFile
+
+/**
+ * Rename handler for Rhai identifiers.
+ * Enables Shift+F6 rename refactoring for variables, functions, constants, etc.
+ */
+class RhaiRenameHandler : RenameHandler {
+
+    override fun isAvailableOnDataContext(dataContext: DataContext): Boolean {
+        val element = getTargetElement(dataContext) ?: return false
+        return isRenamableElement(element)
+    }
+
+    override fun isRenaming(dataContext: DataContext): Boolean {
+        return isAvailableOnDataContext(dataContext)
+    }
+
+    override fun invoke(project: Project, editor: Editor?, file: PsiFile?, dataContext: DataContext) {
+        val element = getTargetElement(dataContext) ?: return
+        if (editor == null || file == null) return
+
+        if (isRenamableElement(element)) {
+            // Use built-in rename dialog with our element
+            PsiElementRenameHandler.invoke(element, project, element, editor)
+        }
+    }
+
+    override fun invoke(project: Project, elements: Array<out PsiElement>, dataContext: DataContext) {
+        if (elements.isNotEmpty()) {
+            val editor = CommonDataKeys.EDITOR.getData(dataContext)
+            if (editor != null) {
+                PsiElementRenameHandler.invoke(elements[0], project, elements[0], editor)
+            }
+        }
+    }
+
+    private fun getTargetElement(dataContext: DataContext): PsiElement? {
+        val editor = CommonDataKeys.EDITOR.getData(dataContext) ?: return null
+        val file = CommonDataKeys.PSI_FILE.getData(dataContext) ?: return null
+
+        if (file !is RhaiFile) return null
+
+        val offset = editor.caretModel.offset
+        return file.findElementAt(offset)
+    }
+
+    private fun isRenamableElement(element: PsiElement): Boolean {
+        // Only allow renaming IDENTIFIER tokens
+        if (element.elementType != RhaiTypes.IDENTIFIER) return false
+
+        val name = element.text
+
+        // Don't allow renaming keywords
+        val keywords = setOf(
+            "let", "const", "fn", "if", "else", "while", "for", "in",
+            "loop", "break", "continue", "return", "throw", "try", "catch",
+            "switch", "default", "import", "export", "module", "private", "pub",
+            "true", "false", "null", "this", "global", "is", "as"
+        )
+        if (keywords.contains(name)) return false
+
+        // Don't allow renaming built-in functions
+        val builtins = setOf(
+            "print", "println", "debug", "type_of", "is_def",
+            "to_string", "to_int", "to_float", "to_decimal",
+            "abs", "sin", "cos", "tan", "sqrt", "exp", "ln", "log",
+            "push", "pop", "shift", "insert", "remove", "reverse", "sort",
+            "map", "filter", "reduce", "some", "all", "for_each",
+            "keys", "values", "len", "contains", "trim", "replace", "split"
+        )
+        if (builtins.contains(name)) return false
+
+        return true
+    }
+}