more variable show inline values

Author: CppCXY

src/main/java/com/tang/intellij/lua/debugger/LuaDebugVariableContext.kt

@@ -16,16 +16,20 @@
 
 package com.tang.intellij.lua.debugger
 
+import com.intellij.openapi.application.ReadAction
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.util.TextRange
 import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.PsiDocumentManager
+import com.intellij.psi.PsiFile
 import com.intellij.xdebugger.XDebuggerUtil
 import com.intellij.xdebugger.XSourcePosition
 import com.intellij.xdebugger.frame.XStackFrame
 import com.tang.intellij.lua.debugger.emmy.EmmyDebugStackFrame
 import com.tang.intellij.lua.debugger.emmy.value.LuaXValue
 import com.tang.intellij.lua.editor.LuaEditorUtil
 import com.tang.intellij.lua.lang.LSPIJUtils
+import com.tang.intellij.lua.psi.LuaPsiFile
 
 /**
  * Context for tracking variable positions during debugging
@@ -34,24 +38,41 @@ import com.tang.intellij.lua.lang.LSPIJUtils
 class LuaDebugVariableContext(
     private val stackFrame: XStackFrame
 ) {
-    private val variableRanges = mutableMapOf<String, TextRange>()
-    private val variablePositions = mutableMapOf<String, XSourcePosition>()
+    // Store multiple ranges for each variable (for multiple occurrences)
+    private val variableRanges = mutableMapOf<String, MutableList<TextRange>>()
+    private val variablePositions = mutableMapOf<String, MutableList<XSourcePosition>>()
     private val providers = mutableListOf<LuaDebugVariablePositionProvider>()
     private var editor: Editor? = null
     private var endLineOffset: Int = -1
+    private var psiFile: PsiFile? = null
+    private var sourcePosition: XSourcePosition? = null
 
     init {
-        // Register default provider
-        providers.add(LuaHighlighterDebugVariablePositionProvider())
+        // Register PSI-based provider (more accurate than highlighter-based)
+        providers.add(LuaPsiDebugVariablePositionProvider())
+        
+        println("LuaDebugVariableContext: Initializing...")
+        
+        // Initialize editor and PSI file if available
+        sourcePosition = stackFrame.sourcePosition
+        println("LuaDebugVariableContext: sourcePosition = $sourcePosition")
 
-        // Initialize editor if available
-        val sourcePosition = stackFrame.sourcePosition
         if (sourcePosition != null && stackFrame is EmmyDebugStackFrame) {
             val project = stackFrame.process.session.project
-            val editors = LuaEditorUtil.findEditors(project, sourcePosition.file)
+            val editors = LuaEditorUtil.findEditors(project, sourcePosition!!.file)
             editor = editors.firstOrNull()
+            
+            println("LuaDebugVariableContext: Found ${editors.size} editors, using first: $editor")
+            
             if (editor != null) {
-                endLineOffset = editor!!.document.getLineEndOffset(sourcePosition.line)
+                endLineOffset = editor!!.document.getLineEndOffset(sourcePosition!!.line)
+                println("LuaDebugVariableContext: endLineOffset = $endLineOffset")
+                
+                // Get PSI file from document - must be done in ReadAction
+                ReadAction.run<RuntimeException> {
+                    psiFile = PsiDocumentManager.getInstance(project).getPsiFile(editor!!.document)
+                    println("LuaDebugVariableContext: psiFile = $psiFile (${psiFile?.javaClass?.simpleName})")
+                }
             }
         }
     }
@@ -79,52 +100,118 @@ class LuaDebugVariableContext(
     fun getEndLineOffset(): Int = endLineOffset
 
     /**
-     * Add a variable range
+     * Get the PSI file for this context
+     */
+    fun getPsiFile(): PsiFile? = psiFile
+    
+    /**
+     * Get the source position for this context
+     */
+    fun getSourcePosition(): XSourcePosition? = sourcePosition
+    
+    /**
+     * Add a variable range (supports multiple occurrences of the same variable)
      */
     fun addVariableRange(variableName: String, textRange: TextRange) {
-        variableRanges[variableName] = textRange
+        val ranges = variableRanges.getOrPut(variableName) { mutableListOf() }
+        ranges.add(textRange)
     }
 
     /**
      * Add a variable position
      */
     fun addVariablePosition(variableName: String, position: XSourcePosition) {
-        variablePositions[variableName] = position
+        val positions = variablePositions.getOrPut(variableName) { mutableListOf() }
+        positions.add(position)
     }
 
     /**
-     * Get source position for a variable name
+     * Get all source positions for a variable name
+     * This is used to display inline values at all occurrences of the variable
      */
-    fun getSourcePosition(name: String): XSourcePosition? {
-        // Return cached position if available
-        variablePositions[name]?.let { return it }
+    fun getAllSourcePositions(name: String): List<XSourcePosition> {
+        println("LuaDebugVariableContext.getAllSourcePositions: Looking for all positions of '$name'")
 
-        // Try to create position from range
-        val textRange = variableRanges[name] ?: return null
-        val file = getFile() ?: return null
-        val ed = editor ?: return null
+        // Return cached positions if available
+        variablePositions[name]?.let {
+            if (it.isNotEmpty()) {
+                println("LuaDebugVariableContext.getAllSourcePositions: Found ${it.size} cached positions for '$name'")
+                return it
+            }
+        }
 
-        val range = com.tang.intellij.lua.lang.LSPIJUtils.toRange(textRange, ed.document)
-        val position = XDebuggerUtil.getInstance()
-            .createPosition(file, range.start.line, range.end.character)
+        // Try to create positions from all ranges
+        val ranges = variableRanges[name]
+        if (ranges == null || ranges.isEmpty()) {
+            println("LuaDebugVariableContext.getAllSourcePositions: No ranges found for '$name'")
+            println("LuaDebugVariableContext.getAllSourcePositions: Available variables: ${variableRanges.keys}")
+            return emptyList()
+        }
 
-        if (position != null) {
-            addVariablePosition(name, position)
+        val file = getFile()
+        if (file == null) {
+            println("LuaDebugVariableContext.getAllSourcePositions: file is null")
+            return emptyList()
         }
 
-        return position
+        val ed = editor
+        if (ed == null) {
+            println("LuaDebugVariableContext.getAllSourcePositions: editor is null")
+            return emptyList()
+        }
+        
+        // Create positions for all occurrences
+        val positions = mutableListOf<XSourcePosition>()
+        for (textRange in ranges) {
+            val range = com.tang.intellij.lua.lang.LSPIJUtils.toRange(textRange, ed.document)
+            println("LuaDebugVariableContext.getAllSourcePositions: Range for '$name': line ${range.start.line}, char ${range.start.character}-${range.end.character}")
+            
+            val position = XDebuggerUtil.getInstance()
+                .createPosition(file, range.start.line, range.start.character)
+            
+            if (position != null) {
+                println("LuaDebugVariableContext.getAllSourcePositions: Created position: $position")
+                positions.add(position)
+            }
+        }
+        
+        // Cache the positions
+        if (positions.isNotEmpty()) {
+            variablePositions[name] = positions.toMutableList()
+        }
+        
+        println("LuaDebugVariableContext.getAllSourcePositions: Returning ${positions.size} positions for '$name'")
+        return positions
     }
 
     /**
-     * Get source position for a variable value
+     * Get source position for a variable name
+     * Returns the first occurrence position (can be extended to return all)
      */
-    fun getSourcePositionFor(value: LuaXValue): XSourcePosition? {
+    fun getSourcePosition(name: String): XSourcePosition? {
+        val positions = getAllSourcePositions(name)
+        return positions.firstOrNull()
+    }
+    
+    /**
+     * Get all source positions for a variable value
+     */
+    fun getAllSourcePositionsFor(value: LuaXValue): List<XSourcePosition> {
         for (provider in providers) {
+            // For now, use getSourcePosition - could be extended to support multiple positions from provider
             val position = provider.getSourcePosition(value, this)
             if (position != null) {
-                return position
+                // Return all positions for this variable name
+                return getAllSourcePositions(value.name)
             }
         }
-        return null
+        return emptyList()
+    }
+    
+    /**
+     * Get source position for a variable value
+     */
+    fun getSourcePositionFor(value: LuaXValue): XSourcePosition? {
+        return getAllSourcePositionsFor(value).firstOrNull()
     }
 }

src/main/java/com/tang/intellij/lua/debugger/LuaDebuggerEvaluator.kt

@@ -16,6 +16,7 @@
 
 package com.tang.intellij.lua.debugger
 
+import com.intellij.openapi.application.ApplicationManager
 import com.intellij.openapi.editor.Document
 import com.intellij.openapi.project.IndexNotReadyException
 import com.intellij.openapi.project.Project
@@ -32,18 +33,27 @@ import com.tang.intellij.lua.psi.*
  * Created by tangzx on 2017/5/1.
  */
 abstract class LuaDebuggerEvaluator : XDebuggerEvaluator() {
-    override fun getExpressionRangeAtOffset(project: Project, document: Document, offset: Int, sideEffectsAllowed: Boolean): TextRange? {
+    override fun getExpressionRangeAtOffset(
+        project: Project,
+        document: Document,
+        offset: Int,
+        sideEffectsAllowed: Boolean
+    ): TextRange? {
         var currentRange: TextRange? = null
-        PsiDocumentManager.getInstance(project).commitAndRunReadAction {
+
+        val computeRange = computeRange@{
             try {
-                val file = PsiDocumentManager.getInstance(project).getPsiFile(document) ?: return@commitAndRunReadAction
+                val psiDocManager = PsiDocumentManager.getInstance(project)
+                val file = psiDocManager.getPsiFile(document) ?: return@computeRange
+
                 if (currentRange == null) {
                     val ele = file.findElementAt(offset)
                     if (ele != null && ele.node.elementType == LuaTypes.ID) {
                         val parent = ele.parent
                         when (parent) {
                             is LuaFuncDef,
                             is LuaLocalFuncDef -> currentRange = ele.textRange
+
                             is LuaClassMethodName,
                             is PsiNameIdentifierOwner -> currentRange = parent.textRange
                         }
@@ -56,16 +66,31 @@ abstract class LuaDebuggerEvaluator : XDebuggerEvaluator() {
                         is LuaCallExpr,
                         is LuaClosureExpr,
                         is LuaLiteralExpr -> null
+
                         else -> expr?.textRange
                     }
                 }
             } catch (ignored: IndexNotReadyException) {
             }
         }
+
+        // Check if we're already in a read action to avoid deadlock
+        if (ApplicationManager.getApplication().isReadAccessAllowed) {
+            // Already in read action, just execute directly
+            computeRange()
+        } else {
+            // Not in read action, need to commit and run in read action
+            PsiDocumentManager.getInstance(project).commitAndRunReadAction(computeRange)
+        }
+
         return currentRange
     }
 
-    override fun evaluate(express: String, xEvaluationCallback: XDebuggerEvaluator.XEvaluationCallback, xSourcePosition: XSourcePosition?) {
+    override fun evaluate(
+        express: String,
+        xEvaluationCallback: XDebuggerEvaluator.XEvaluationCallback,
+        xSourcePosition: XSourcePosition?
+    ) {
         var expr = express.trim()
         if (!expr.endsWith(')')) {
             val lastDot = express.lastIndexOf('.')
@@ -76,5 +101,9 @@ abstract class LuaDebuggerEvaluator : XDebuggerEvaluator() {
         eval(expr, xEvaluationCallback, xSourcePosition)
     }
 
-    protected abstract fun eval(express: String, xEvaluationCallback: XDebuggerEvaluator.XEvaluationCallback, xSourcePosition: XSourcePosition?)
+    protected abstract fun eval(
+        express: String,
+        xEvaluationCallback: XDebuggerEvaluator.XEvaluationCallback,
+        xSourcePosition: XSourcePosition?
+    )
 }