Debugger: correct scope for runtime type calculation

Author: NataliaUkhorskaya

ChangeLog.md

@@ -11,6 +11,10 @@
 
 ### IDE
 
+#### Debugger
+
+- Do not cast to runtime type unavailable in current scope
+
 ## 1.0.2
 
 ### Compiler

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/FrameVisitor.kt

@@ -35,7 +35,7 @@ import org.jetbrains.kotlin.resolve.jvm.AsmTypes
 import org.jetbrains.org.objectweb.asm.Type
 
 class FrameVisitor(context: EvaluationContextImpl) {
-    private val project = context.debugProcess.project
+    private val scope = context.debugProcess.searchScope
     private val frame = context.frameProxy
 
     companion object {
@@ -177,16 +177,15 @@ class FrameVisitor(context: EvaluationContextImpl) {
 
     private fun isValueOfCorrectType(value: Value, asmType: Type?, shouldCheckType: Boolean): Boolean {
         if (!shouldCheckType || asmType == null || value.asmType == asmType) return true
-        if (project == null) return false
 
         if (asmType == OBJECT_TYPE) return true
 
         if ((value.obj() as? com.sun.jdi.ObjectReference)?.referenceType().isSubclass(asmType.className)) {
             return true
         }
 
-        val thisDesc = value.asmType.getClassDescriptor(project)
-        val expDesc = asmType.getClassDescriptor(project)
+        val thisDesc = value.asmType.getClassDescriptor(scope)
+        val expDesc = asmType.getClassDescriptor(scope)
         return thisDesc != null && expDesc != null && runReadAction { DescriptorUtils.isSubclass(thisDesc, expDesc) }
     }
 

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinCodeFragmentFactory.kt

@@ -262,7 +262,7 @@ class KotlinCodeFragmentFactory: CodeFragmentFactory() {
         }
 
         private fun createKotlinProperty(project: Project, variableName: String, variableTypeName: String, value: Value): String? {
-            val actualClassDescriptor = value.asValue().asmType.getClassDescriptor(project)
+            val actualClassDescriptor = value.asValue().asmType.getClassDescriptor(GlobalSearchScope.allScope(project))
             if (actualClassDescriptor != null && actualClassDescriptor.defaultType.arguments.isEmpty()) {
                 val renderedType = IdeDescriptorRenderers.SOURCE_CODE.renderType(actualClassDescriptor.defaultType.makeNullable())
                 return "val ${variableName.quoteIfNeeded()}: $renderedType = null"

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinDebuggerCaches.kt

@@ -187,7 +187,7 @@ class KotlinDebuggerCaches(private val project: Project) {
             val value = frameVisitor.findValue(name, asmType = null, checkType = false, failIfNotFound = false)
             if (value == null) return@all false
 
-            val thisDescriptor = value.asmType.getClassDescriptor(project)
+            val thisDescriptor = value.asmType.getClassDescriptor(context.debugProcess.searchScope)
             val superClassDescriptor = jetType.constructor.declarationDescriptor as? ClassDescriptor
             return@all thisDescriptor != null && superClassDescriptor != null && runReadAction { DescriptorUtils.isSubclass(thisDescriptor, superClassDescriptor) }
         }

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -26,7 +26,6 @@ import com.intellij.diagnostic.LogMessageEx
 import com.intellij.openapi.diagnostic.Attachment
 import com.intellij.openapi.diagnostic.Logger
 import com.intellij.openapi.progress.ProcessCanceledException
-import com.intellij.openapi.project.Project
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.psi.JavaPsiFacade
 import com.intellij.psi.PsiDocumentManager
@@ -552,7 +551,7 @@ private fun SuspendContext.getInvokePolicy(): Int {
     return if (suspendPolicy == EventRequest.SUSPEND_EVENT_THREAD) ObjectReference.INVOKE_SINGLE_THREADED else 0
 }
 
-fun Type.getClassDescriptor(project: Project): ClassDescriptor? {
+fun Type.getClassDescriptor(scope: GlobalSearchScope): ClassDescriptor? {
     if (AsmUtil.isPrimitive(this)) return null
 
     val jvmName = JvmClassName.byInternalName(internalName).fqNameForClassNameWithoutDollars
@@ -561,7 +560,7 @@ fun Type.getClassDescriptor(project: Project): ClassDescriptor? {
     if (platformClasses.isNotEmpty()) return platformClasses.first()
 
     return runReadAction {
-        val classes = JavaPsiFacade.getInstance(project).findClasses(jvmName.asString(), GlobalSearchScope.allScope(project))
+        val classes = JavaPsiFacade.getInstance(scope.project).findClasses(jvmName.asString(), scope)
         if (classes.isEmpty()) null
         else {
             classes.first().getJavaClassDescriptor()

idea/src/org/jetbrains/kotlin/idea/debugger/evaluate/KotlinRuntimeTypeEvaluator.kt

@@ -29,8 +29,8 @@ import com.intellij.debugger.ui.EditorEvaluationCommand
 import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.progress.ProcessCanceledException
 import com.intellij.openapi.progress.ProgressIndicator
-import com.intellij.openapi.project.Project
 import com.intellij.psi.CommonClassNames
+import com.intellij.psi.search.GlobalSearchScope
 import com.sun.jdi.ClassType
 import com.sun.jdi.Value
 import org.jetbrains.eval4j.jdi.asValue
@@ -73,16 +73,16 @@ abstract class KotlinRuntimeTypeEvaluator(
 
         val value = evaluator.evaluate(evaluationContext)
         if (value != null) {
-            return getCastableRuntimeType(project, value)
+            return getCastableRuntimeType(evaluationContext.debugProcess.searchScope, value)
         }
 
         throw EvaluateExceptionUtil.createEvaluateException(DebuggerBundle.message("evaluation.error.surrounded.expression.null"))
     }
 
     companion object {
-        private fun getCastableRuntimeType(project: Project, value: Value): KotlinType? {
+        private fun getCastableRuntimeType(scope: GlobalSearchScope, value: Value): KotlinType? {
             val myValue = value.asValue()
-            var psiClass = myValue.asmType.getClassDescriptor(project)
+            var psiClass = myValue.asmType.getClassDescriptor(scope)
             if (psiClass != null) {
                 return psiClass.defaultType
             }
@@ -91,14 +91,14 @@ abstract class KotlinRuntimeTypeEvaluator(
             if (type is ClassType) {
                 val superclass = type.superclass()
                 if (superclass != null && CommonClassNames.JAVA_LANG_OBJECT != superclass.name()) {
-                    psiClass = AsmType.getType(superclass.signature()).getClassDescriptor(project)
+                    psiClass = AsmType.getType(superclass.signature()).getClassDescriptor(scope)
                     if (psiClass != null) {
                         return psiClass.defaultType
                     }
                 }
 
                 for (interfaceType in type.interfaces()) {
-                    psiClass = AsmType.getType(interfaceType.signature()).getClassDescriptor(project)
+                    psiClass = AsmType.getType(interfaceType.signature()).getClassDescriptor(scope)
                     if (psiClass != null) {
                         return psiClass.defaultType
                     }