Make JetCodeFragment implements JavaCodeFragment

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetCodeFragment.kt

@@ -24,6 +24,7 @@ import com.intellij.psi.search.GlobalSearchScope
 import com.intellij.psi.tree.IElementType
 import com.intellij.testFramework.LightVirtualFile
 import org.jetbrains.jet.plugin.JetFileType
+import java.util.HashSet
 
 public abstract class JetCodeFragment(
         val _project: Project,
@@ -31,15 +32,20 @@ public abstract class JetCodeFragment(
         text: CharSequence,
         elementType: IElementType,
         val _context: PsiElement?
-): JetFile((PsiManager.getInstance(_project) as PsiManagerEx).getFileManager().createFileViewProvider(LightVirtualFile(name, JetFileType.INSTANCE, text), true), false), PsiCodeFragment {
+): JetFile((PsiManager.getInstance(_project) as PsiManagerEx).getFileManager().createFileViewProvider(LightVirtualFile(name, JetFileType.INSTANCE, text), true), false), JavaCodeFragment {
+
+    private var _viewProvider = super<JetFile>.getViewProvider() as SingleRootFileViewProvider
+    private var _myImports = HashSet<String>();
 
     {
-        (getViewProvider() as SingleRootFileViewProvider).forceCachedPsi(this)
+        getViewProvider().forceCachedPsi(this)
         init(TokenType.CODE_FRAGMENT, elementType)
     }
 
     private var _resolveScope: GlobalSearchScope? = null
-    private var _viewProvider: FileViewProvider? = null
+    private var _thisType: PsiType? = null
+    private var _superType: PsiType? = null
+    private var _exceptionHandler: JavaCodeFragment.ExceptionHandler? = null
 
     override fun forceResolveScope(scope: GlobalSearchScope?) {
         _resolveScope = scope
@@ -58,12 +64,51 @@ public abstract class JetCodeFragment(
     override fun clone(): JetCodeFragment {
         val clone = cloneImpl(calcTreeElement().clone() as FileElement) as JetCodeFragment
         clone.setOriginalFile(this)
-        val fileManager = (PsiManager.getInstance(_project) as PsiManagerEx).getFileManager()
+        clone._myImports = _myImports
-        val cloneViewProvider = fileManager.createFileViewProvider(LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true) as SingleRootFileViewProvider
+        clone._viewProvider = SingleRootFileViewProvider(PsiManager.getInstance(_project), LightVirtualFile(getName(), JetFileType.INSTANCE, getText()), true)
-        cloneViewProvider.forceCachedPsi(clone)
+        clone._viewProvider.forceCachedPsi(clone)
-        clone._viewProvider = cloneViewProvider
         return clone
     }
 
-    override fun getViewProvider() = _viewProvider ?: super<JetFile>.getViewProvider()
+    override fun getViewProvider() = _viewProvider
+
+    override fun getThisType() = _thisType
+
+    override fun setThisType(psiType: PsiType?) {
+        _thisType = psiType
+    }
+
+    override fun getSuperType() = _superType
+
+    override fun setSuperType(superType: PsiType?) {
+        _superType = superType
+    }
+
+    override fun importsToString(): String {
+        return _myImports.makeString(IMPORT_SEPARATOR)
+    }
+
+    override fun addImportsFromString(imports: String?) {
+        if (imports == null) return
+
+        _myImports.addAll(imports.split(IMPORT_SEPARATOR))
+    }
+
+    override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) { }
+
+    override fun getVisibilityChecker() = JavaCodeFragment.VisibilityChecker.EVERYTHING_VISIBLE
+
+    override fun setExceptionHandler(checker: JavaCodeFragment.ExceptionHandler?) {
+        _exceptionHandler = checker
+    }
+
+    override fun getExceptionHandler() = _exceptionHandler
+
+    override fun importClass(aClass: PsiClass?): Boolean {
+        return true
+    }
+
+    class object {
+        val IMPORT_SEPARATOR = ","
+    }
 }

compiler/frontend/src/org/jetbrains/jet/lang/psi/JetExpressionCodeFragment.kt

@@ -28,50 +28,7 @@ public class JetExpressionCodeFragment(
         name: String,
         text: CharSequence,
         context: PsiElement?
-) : JetCodeFragment(project, name, text, JetNodeTypes.EXPRESSION_CODE_FRAGMENT, context), JavaCodeFragment {
+) : JetCodeFragment(project, name, text, JetNodeTypes.EXPRESSION_CODE_FRAGMENT, context) {
-
-    private var _thisType: PsiType? = null
-    private var _superType: PsiType? = null
-    private var _exceptionHandler: JavaCodeFragment.ExceptionHandler? = null
-
-    private val myImports: MutableSet<String> = hashSetOf()
-
-    override fun getThisType() = _thisType
-
-    override fun setThisType(psiType: PsiType?) {
-        _thisType = psiType
-    }
-
-    override fun getSuperType() = _superType
-
-    override fun setSuperType(superType: PsiType?) {
-        _superType = superType
-    }
-
-    override fun importsToString(): String {
-        return myImports.makeString(IMPORT_SEPARATOR)
-    }
-
-    override fun addImportsFromString(imports: String?) {
-        if (imports == null) return
-
-        myImports.addAll(imports.split(IMPORT_SEPARATOR))
-    }
-
-    override fun setVisibilityChecker(checker: JavaCodeFragment.VisibilityChecker?) {
-    }
-
-    override fun getVisibilityChecker() = JavaCodeFragment.VisibilityChecker.EVERYTHING_VISIBLE
-
-    override fun setExceptionHandler(checker: JavaCodeFragment.ExceptionHandler?) {
-        _exceptionHandler = checker
-    }
-
-    override fun getExceptionHandler() = _exceptionHandler
-
-    override fun importClass(aClass: PsiClass?): Boolean {
-        return true
-    }
 
     fun getExpression(): JetExpression? {
         var resultingExpression: JetExpression? = null
@@ -86,8 +43,4 @@ public class JetExpressionCodeFragment(
         }, null)
         return resultingExpression
     }
-
-    class object {
-        val IMPORT_SEPARATOR = ","
-    }
 }

idea/src/org/jetbrains/jet/plugin/debugger/KotlinEditorTextProvider.kt

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.psi.JetOperationExpression
 import org.jetbrains.jet.lang.psi.JetExpression
 import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
 import org.jetbrains.jet.lang.psi.JetSuperExpression
+import org.jetbrains.jet.lang.psi.JetCodeFragment
 
 class KotlinEditorTextProvider : EditorTextProvider {
     override fun getEditorText(elementAtCaret: PsiElement): TextWithImports? {
@@ -55,7 +56,7 @@ class KotlinEditorTextProvider : EditorTextProvider {
 
             return containingFile.getImportList()?.getImports()
                                 ?.map { it.getText() }
-                                ?.makeString(JetExpressionCodeFragment.IMPORT_SEPARATOR) ?: ""
+                                ?.makeString(JetCodeFragment.IMPORT_SEPARATOR) ?: ""
         }
 
         fun findExpressionInner(element: PsiElement): JetExpression? {

idea/src/org/jetbrains/jet/plugin/debugger/evaluate/KotlinEvaluationBuilder.kt

@@ -65,6 +65,7 @@ import org.jetbrains.jet.OutputFileCollection
 import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
 import org.jetbrains.jet.lang.psi.JetExpressionCodeFragment
 import org.jetbrains.jet.plugin.caches.resolve.getAnalysisResults
+import org.jetbrains.jet.lang.psi.JetCodeFragment
 
 object KotlinEvaluationBuilder: EvaluatorBuilder {
     override fun build(codeFragment: PsiElement, position: SourcePosition?): ExpressionEvaluator {
@@ -222,7 +223,7 @@ private fun createFileForDebugger(codeFragment: JetExpressionCodeFragment,
 ): JetFile {
     var fileText = template.replace("!IMPORT_LIST!",
                                     codeFragment.importsToString()
-                                            .split(JetExpressionCodeFragment.IMPORT_SEPARATOR)
+                                            .split(JetCodeFragment.IMPORT_SEPARATOR)
                                             .makeString("\n"))
 
     fileText = fileText.replace("!FUNCTION!", extractedFunction.getText())