[LL FIR] fix contract violation exception from Java Resolution

When we create `SmartTypePointer` directly inside `JavaSymbolProvider`,
the Java resolution is called which is forbidden inside the
`JavaSymbolProvider`.

Instead, the lazy `JavaElementTypeSource` for JavaType is created,
which creates a `SmartTypePointer` outside `JavaSymbolProvider`.

^KT-58194

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/java/source/JavaElementDelegatingTypeSourceWithSmartPointer.kt

@@ -0,0 +1,49 @@
+package org.jetbrains.kotlin.analysis.api.impl.base.java.source
+
+import com.intellij.psi.*
+import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory
+import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementTypeSource
+
+internal abstract class JavaElementDelegatingTypeSourceWithSmartPointer<PSI : PsiElement, TYPE : PsiType> : JavaElementTypeSource<TYPE>() {
+    abstract val psiPointer: SmartPsiElementPointer<out PSI>
+    abstract fun getType(psi: PSI): TYPE
+
+    override val type: TYPE
+        get() {
+            val psi = psiPointer.element
+                ?: error("Cannot restore $psiPointer")
+            return getType(psi)
+        }
+}
+
+internal class JavaElementDelegatingVariableReturnTypeSourceWithSmartPointer<TYPE : PsiType>(
+    override val psiPointer: SmartPsiElementPointer<out PsiVariable>,
+    override val factory: JavaElementSourceFactory,
+) : JavaElementDelegatingTypeSourceWithSmartPointer<PsiVariable, TYPE>() {
+
+    override fun getType(psi: PsiVariable): TYPE {
+        @Suppress("UNCHECKED_CAST")
+        return psi.type as TYPE
+    }
+}
+
+internal class JavaElementDelegatingMethodReturnTypeSourceWithSmartPointer<TYPE : PsiType>(
+    override val psiPointer: SmartPsiElementPointer<out PsiMethod>,
+    override val factory: JavaElementSourceFactory,
+) : JavaElementDelegatingTypeSourceWithSmartPointer<PsiMethod, TYPE>() {
+
+    override fun getType(psi: PsiMethod): TYPE {
+        @Suppress("UNCHECKED_CAST")
+        return psi.returnType as TYPE
+    }
+}
+internal class JavaElementDelegatingExpressionTypeSourceWithSmartPointer<TYPE : PsiType>(
+    override val psiPointer: SmartPsiElementPointer<out PsiExpression>,
+    override val factory: JavaElementSourceFactory,
+) : JavaElementDelegatingTypeSourceWithSmartPointer<PsiExpression, TYPE>() {
+
+    override fun getType(psi: PsiExpression): TYPE {
+        @Suppress("UNCHECKED_CAST")
+        return psi.type as TYPE
+    }
+}

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/java/source/JavaElementPsiSourceWithSmartPointer.kt

@@ -11,7 +11,7 @@ import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementPsiSource
 import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory
 
 internal class JavaElementPsiSourceWithSmartPointer<PSI : PsiElement>(
-    private val pointer: SmartPsiElementPointer<PSI>,
+    val pointer: SmartPsiElementPointer<PSI>,
     override val factory: JavaElementSourceFactory,
 ) : JavaElementPsiSource<PSI>() {
 
@@ -20,9 +20,5 @@ internal class JavaElementPsiSourceWithSmartPointer<PSI : PsiElement>(
             return pointer.element
                 ?: error("Cannot restore a PsiElement from $pointer")
         }
-
-    override fun toString(): String {
-        return pointer.element?.toString() ?: "Cannot restore a PsiElement from $pointer"
-    }
 }
 

analysis/analysis-api-impl-base/src/org/jetbrains/kotlin/analysis/api/impl/base/java/source/JavaElementSourceWithSmartPointerFactory.kt

@@ -6,15 +6,12 @@
 package org.jetbrains.kotlin.analysis.api.impl.base.java.source
 
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiType
-import com.intellij.psi.SmartPointerManager
-import com.intellij.psi.SmartTypePointerManager
+import com.intellij.psi.*
 import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementPsiSource
 import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementSourceFactory
 import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementTypeSource
 
- class JavaElementSourceWithSmartPointerFactory(project: Project) : JavaElementSourceFactory() {
+class JavaElementSourceWithSmartPointerFactory(project: Project) : JavaElementSourceFactory() {
     private val smartTypePointerManager = SmartTypePointerManager.getInstance(project)
     private val smartPsiPointerManager = SmartPointerManager.getInstance(project)
 
@@ -25,4 +22,19 @@ import org.jetbrains.kotlin.load.java.structure.impl.source.JavaElementTypeSourc
     override fun <TYPE : PsiType> createTypeSource(type: TYPE): JavaElementTypeSource<TYPE> {
         return JavaElementTypeSourceWithSmartPointer(smartTypePointerManager.createSmartTypePointer(type), this)
     }
+
+    override fun <TYPE : PsiType> createVariableReturnTypeSource(psiVariableSource: JavaElementPsiSource<out PsiVariable>): JavaElementTypeSource<TYPE> {
+        require(psiVariableSource is JavaElementPsiSourceWithSmartPointer)
+        return JavaElementDelegatingVariableReturnTypeSourceWithSmartPointer(psiVariableSource.pointer, psiVariableSource.factory)
+    }
+
+    override fun <TYPE : PsiType> createMethodReturnTypeSource(psiMethodSource: JavaElementPsiSource<out PsiMethod>): JavaElementTypeSource<TYPE> {
+        require(psiMethodSource is JavaElementPsiSourceWithSmartPointer)
+        return JavaElementDelegatingMethodReturnTypeSourceWithSmartPointer(psiMethodSource.pointer, psiMethodSource.factory)
+    }
+
+    override fun <TYPE : PsiType> createExpressionTypeSource(psiExpressionSource: JavaElementPsiSource<out PsiExpression>): JavaElementTypeSource<TYPE> {
+        require(psiExpressionSource is JavaElementPsiSourceWithSmartPointer)
+        return JavaElementDelegatingExpressionTypeSourceWithSmartPointer(psiExpressionSource.pointer, psiExpressionSource.factory)
+    }
 }