PR-1021: Merge Keplin project scripting code into Kotlin core.

Overhauls the scripting layers (GenericRepl and related, and JSR223 and related) Adds repeating modes (none, only latest eval'd line, or random order) Also adds better thread-safe IO capturing, default imports, SimpleRepl wrapper, more unit tests NOTE: the script-util part of the pull request was rejected due to various problems and incompatibilities. It may be incorporated into the code later. (originally cherry picked from commit 6f7d517)
2017-01-18 04:17:41 +01:00
parent 8caf607378
commit 5ad06e1e92
29 changed files with 1146 additions and 548 deletions
@@ -17,43 +17,71 @@
 package org.jetbrains.kotlin.cli.jvm.repl

 import com.intellij.openapi.Disposable
-import com.intellij.openapi.diagnostic.Logger
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.repl.*
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
 import org.jetbrains.kotlin.config.CompilerConfiguration
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
+import java.io.File
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.locks.ReentrantReadWriteLock

-private val logger = Logger.getInstance(GenericRepl::class.java)
-
-open class GenericRepl(
+open class GenericRepl protected constructor(
        disposable: Disposable,
        scriptDefinition: KotlinScriptDefinition,
        compilerConfiguration: CompilerConfiguration,
        messageCollector: MessageCollector,
        baseClassloader: ClassLoader?,
-        scriptArgs: Array<Any?>? = null,
-        scriptArgsTypes: Array<Class<*>>? = null
-) : ReplEvaluator, GenericReplCompiler(disposable, scriptDefinition, compilerConfiguration, messageCollector) {
+        protected val fallbackScriptArgs: ScriptArgsWithTypes?,
+        protected val repeatingMode: ReplRepeatingMode = ReplRepeatingMode.NONE,
+        protected val stateLock: ReentrantReadWriteLock
+) : ReplCompiler, ReplEvaluator, ReplAtomicEvaluator {
+    constructor (
+            disposable: Disposable,
+            scriptDefinition: KotlinScriptDefinition,
+            compilerConfiguration: CompilerConfiguration,
+            messageCollector: MessageCollector,
+            baseClassloader: ClassLoader?,
+            fallbackScriptArgs: ScriptArgsWithTypes? = null
+    ) : this(disposable, scriptDefinition, compilerConfiguration, messageCollector, baseClassloader, fallbackScriptArgs, stateLock = ReentrantReadWriteLock())

-    private val compiledEvaluator = GenericReplCompiledEvaluator(compilerConfiguration.jvmClasspathRoots, baseClassloader, scriptArgs, scriptArgsTypes)
+    protected val compiler: ReplCompiler by lazy { GenericReplCompiler(disposable, scriptDefinition, compilerConfiguration, messageCollector, stateLock) }
+    protected val evaluator: ReplFullEvaluator by lazy { GenericReplCompilingEvaluator(compiler, compilerConfiguration.jvmClasspathRoots, baseClassloader, fallbackScriptArgs, repeatingMode, stateLock) }
+    protected var codeLineNumber = AtomicInteger(0)

-    override val lastEvaluatedScript: ClassWithInstance? get() = compiledEvaluator.lastEvaluatedScript
+    override fun resetToLine(lineNumber: Int): List<ReplCodeLine> {
+        return evaluator.resetToLine(lineNumber)
+    }

-    @Synchronized
-    override fun eval(codeLine: ReplCodeLine, history: List<ReplCodeLine>, invokeWrapper: InvokeWrapper?): ReplEvalResult =
-        compileAndEval(this, compiledEvaluator, codeLine, history, invokeWrapper)
-}
+    override fun resetToLine(line: ReplCodeLine): List<ReplCodeLine> {
+        return evaluator.resetToLine(line)
+    }

+    override val history: List<ReplCodeLine> get() = evaluator.history
+    override val compiledHistory: List<ReplCodeLine> get() = compiler.history
+    override val evaluatedHistory: List<ReplCodeLine> get() = evaluator.history

-fun compileAndEval(replCompiler: ReplCompiler, replCompiledEvaluator: ReplCompiledEvaluator, codeLine: ReplCodeLine, history: List<ReplCodeLine>, invokeWrapper: InvokeWrapper?): ReplEvalResult =
-        replCompiler.compile(codeLine, history).let {
-            when (it) {
-                is ReplCompileResult.Incomplete -> ReplEvalResult.Incomplete(it.updatedHistory)
-                is ReplCompileResult.HistoryMismatch -> ReplEvalResult.HistoryMismatch(it.updatedHistory, it.lineNo)
-                is ReplCompileResult.Error -> ReplEvalResult.Error.CompileTime(it.updatedHistory, it.message, it.location)
-                is ReplCompileResult.CompiledClasses -> replCompiledEvaluator.eval(codeLine, history, it.classes, it.hasResult, it.classpathAddendum, invokeWrapper)
-            }
-        }
+    override val currentClasspath: List<File>
+        get() = evaluator.currentClasspath

+    override val lastEvaluatedScripts: List<EvalHistoryType>
+        get() = evaluator.lastEvaluatedScripts

+    override fun check(codeLine: ReplCodeLine): ReplCheckResult {
+        return compiler.check(codeLine)
+    }
+
+    override fun compile(codeLine: ReplCodeLine, verifyHistory: List<ReplCodeLine>?): ReplCompileResult {
+        return compiler.compile(codeLine, verifyHistory)
+    }
+
+    override fun eval(compileResult: ReplCompileResult.CompiledClasses, scriptArgs: ScriptArgsWithTypes?, invokeWrapper: InvokeWrapper?): ReplEvalResult {
+        return evaluator.eval(compileResult, scriptArgs, invokeWrapper)
+    }
+
+    override fun compileAndEval(codeLine: ReplCodeLine, scriptArgs: ScriptArgsWithTypes?, verifyHistory: List<ReplCodeLine>?, invokeWrapper: InvokeWrapper?): ReplEvalResult {
+        return evaluator.compileAndEval(codeLine, scriptArgs, verifyHistory, invokeWrapper)
+    }
+
+    fun nextCodeLine(code: String) = ReplCodeLine(codeLineNumber.incrementAndGet(), code)
+}
@@ -14,9 +14,14 @@
 * limitations under the License.
 */

+@file:Suppress("UNUSED_PARAMETER")
+
 package org.jetbrains.kotlin.cli.jvm.repl

-import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.cli.common.repl.CompiledReplCodeLine
+import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
+import org.jetbrains.kotlin.cli.common.repl.ReplHistory
+import org.jetbrains.kotlin.cli.common.repl.ReplResettableCodeLine
 import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport
 import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
@@ -30,25 +35,36 @@ import org.jetbrains.kotlin.resolve.*
 import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory
 import org.jetbrains.kotlin.resolve.diagnostics.Diagnostics
 import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM
-import org.jetbrains.kotlin.resolve.lazy.ResolveSession
+import org.jetbrains.kotlin.resolve.lazy.*
 import org.jetbrains.kotlin.resolve.lazy.data.KtClassLikeInfo
 import org.jetbrains.kotlin.resolve.lazy.declarations.*
-import org.jetbrains.kotlin.resolve.repl.ReplState
+import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyScriptDescriptor
+import org.jetbrains.kotlin.resolve.scopes.ImportingScope
+import org.jetbrains.kotlin.resolve.scopes.utils.parentsWithSelf
+import org.jetbrains.kotlin.resolve.scopes.utils.replaceImportingScopes
 import org.jetbrains.kotlin.script.ScriptPriorities
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.read
+import kotlin.concurrent.write

-class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
+class GenericReplAnalyzer(environment: KotlinCoreEnvironment,
+                          protected val stateLock: ReentrantReadWriteLock = ReentrantReadWriteLock()) : ReplResettableCodeLine {
    private val topDownAnalysisContext: TopDownAnalysisContext
    private val topDownAnalyzer: LazyTopDownAnalyzer
    private val resolveSession: ResolveSession
    private val scriptDeclarationFactory: ScriptMutableDeclarationProviderFactory
+    private val replState = ResetableReplState()
+
    val module: ModuleDescriptorImpl
-    private val replState = ReplState()
+        get() = stateLock.read { field }
+
    val trace: BindingTraceContext = CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace()
+        get() = stateLock.read { field }

    init {
        // Module source scope is empty because all binary classes are in the dependency module, and all source classes are guaranteed
-        // to be found via ResolveSession. The latter is true as long as light classes are not needed in REPL (which is currently true
-        // because no symbol declared in the REPL session can be used from Java)
+        // to be found via ResolveSession. The latter is true as long as light classes are not needed in NONE (which is currently true
+        // because no symbol declared in the NONE session can be used from Java)
        val container = TopDownAnalyzerFacadeForJVM.createContainer(
                environment.project,
                emptyList(),
@@ -78,18 +94,26 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
        }
    }

-    fun analyzeReplLine(psiFile: KtFile, priority: Int): ReplLineAnalysisResult {
-        topDownAnalysisContext.scripts.clear()
-        trace.clearDiagnostics()
-
-        psiFile.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, priority)
-
-        return doAnalyze(psiFile)
+    override fun resetToLine(lineNumber: Int): List<ReplCodeLine> {
+        return stateLock.write { replState.resetToLine(lineNumber) }
    }

-    private fun doAnalyze(linePsi: KtFile): ReplLineAnalysisResult {
+    override fun resetToLine(line: ReplCodeLine): List<ReplCodeLine> = resetToLine(line.no)
+
+    fun analyzeReplLine(psiFile: KtFile, codeLine: ReplCodeLine): ReplLineAnalysisResult {
+        return stateLock.write {
+            topDownAnalysisContext.scripts.clear()
+            trace.clearDiagnostics()
+
+            psiFile.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, codeLine.no)
+
+            doAnalyze(psiFile, codeLine)
+        }
+    }
+
+    private fun doAnalyze(linePsi: KtFile, codeLine: ReplCodeLine): ReplLineAnalysisResult {
        scriptDeclarationFactory.setDelegateFactory(FileBasedDeclarationProviderFactory(resolveSession.storageManager, listOf(linePsi)))
-        replState.submitLine(linePsi)
+        replState.submitLine(linePsi, codeLine)

        val context = topDownAnalyzer.analyzeDeclarations(topDownAnalysisContext.topDownAnalysisMode, listOf(linePsi))

@@ -100,12 +124,12 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
        val diagnostics = trace.bindingContext.diagnostics
        val hasErrors = diagnostics.any { it.severity == Severity.ERROR }
        if (hasErrors) {
-            replState.lineFailure(linePsi)
+            replState.lineFailure(linePsi, codeLine)
            return ReplLineAnalysisResult.WithErrors(diagnostics)
        }
        else {
            val scriptDescriptor = context.scripts[linePsi.script]!!
-            replState.lineSuccess(linePsi, scriptDescriptor)
+            replState.lineSuccess(linePsi, codeLine, scriptDescriptor)
            return ReplLineAnalysisResult.Successful(scriptDescriptor, diagnostics)
        }

@@ -153,4 +177,60 @@ class CliReplAnalyzerEngine(environment: KotlinCoreEnvironment) {
            }
        }
    }
+
+    class ResetableReplState() {
+        private val successfulLines = ReplHistory<LineInfo.SuccessfulLine>()
+        private val submittedLines = hashMapOf<KtFile, LineInfo>()
+
+        fun resetToLine(lineNumber: Int): List<ReplCodeLine> {
+            val removed = successfulLines.resetToLine(lineNumber)
+            removed.forEach { submittedLines.remove(it.second.linePsi) }
+            return removed.map { it.first }
+        }
+
+        fun resetToLine(line: ReplCodeLine): List<ReplCodeLine> = resetToLine(line.no)
+
+        fun submitLine(ktFile: KtFile, codeLine: ReplCodeLine) {
+            val line = LineInfo.SubmittedLine(ktFile, successfulLines.lastValue())
+            submittedLines[ktFile] = line
+            ktFile.fileScopesCustomizer = object : FileScopesCustomizer {
+                override fun createFileScopes(fileScopeFactory: FileScopeFactory): FileScopes {
+                    return lineInfo(ktFile)?.let { computeFileScopes(it, fileScopeFactory) } ?: fileScopeFactory.createScopesForFile(ktFile)
+                }
+            }
+        }
+
+        fun lineSuccess(ktFile: KtFile, codeLine: ReplCodeLine, scriptDescriptor: LazyScriptDescriptor) {
+            val successfulLine = LineInfo.SuccessfulLine(ktFile, successfulLines.lastValue(), scriptDescriptor)
+            submittedLines[ktFile] = successfulLine
+            successfulLines.add(CompiledReplCodeLine(ktFile.name, codeLine), successfulLine)
+        }
+
+        fun lineFailure(ktFile: KtFile, codeLine: ReplCodeLine) {
+            submittedLines[ktFile] = LineInfo.FailedLine(ktFile, successfulLines.lastValue())
+        }
+
+        private fun lineInfo(ktFile: KtFile) = submittedLines[ktFile]
+
+        // use sealed?
+        private sealed class LineInfo {
+            abstract val linePsi: KtFile
+            abstract val parentLine: SuccessfulLine?
+
+            class SubmittedLine(override val linePsi: KtFile, override val parentLine: SuccessfulLine?) : LineInfo()
+            class SuccessfulLine(override val linePsi: KtFile, override val parentLine: SuccessfulLine?, val lineDescriptor: LazyScriptDescriptor) : LineInfo()
+            class FailedLine(override val linePsi: KtFile, override val parentLine: SuccessfulLine?) : LineInfo()
+        }
+
+        private fun computeFileScopes(lineInfo: LineInfo, fileScopeFactory: FileScopeFactory): FileScopes? {
+            // create scope that wraps previous line lexical scope and adds imports from this line
+            val lexicalScopeAfterLastLine = lineInfo.parentLine?.lineDescriptor?.scopeForInitializerResolution ?: return null
+            val lastLineImports = lexicalScopeAfterLastLine.parentsWithSelf.first { it is ImportingScope } as ImportingScope
+            val scopesForThisLine = fileScopeFactory.createScopesForFile(lineInfo.linePsi, lastLineImports)
+            val combinedLexicalScopes = lexicalScopeAfterLastLine.replaceImportingScopes(scopesForThisLine.importingScope)
+            return FileScopes(combinedLexicalScopes, scopesForThisLine.importingScope, scopesForThisLine.importResolver)
+        }
+    }
 }
+
+
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.cli.jvm.repl

+
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.vfs.CharsetToolkit
 import com.intellij.psi.PsiFileFactory
@@ -25,8 +26,8 @@ import org.jetbrains.kotlin.cli.common.CLIConfigurationKeys
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
 import org.jetbrains.kotlin.cli.common.repl.ReplCheckResult
-import org.jetbrains.kotlin.cli.common.repl.ReplChecker
 import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
+import org.jetbrains.kotlin.cli.common.repl.makeSriptBaseName
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.repl.messages.DiagnosticMessageHolder
@@ -37,14 +38,18 @@ import org.jetbrains.kotlin.idea.KotlinLanguage
 import org.jetbrains.kotlin.parsing.KotlinParserDefinition
 import org.jetbrains.kotlin.psi.KtFile
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.read
+import kotlin.concurrent.write

 open class GenericReplChecker(
        disposable: Disposable,
        val scriptDefinition: KotlinScriptDefinition,
        val compilerConfiguration: CompilerConfiguration,
-        messageCollector: MessageCollector
-) : ReplChecker {
-    protected val environment = run {
+        messageCollector: MessageCollector,
+        protected val stateLock: ReentrantReadWriteLock = ReentrantReadWriteLock()
+) {
+    internal val environment = run {
        compilerConfiguration.apply {
            add(JVMConfigurationKeys.SCRIPT_DEFINITIONS, scriptDefinition)
            put<MessageCollector>(CLIConfigurationKeys.MESSAGE_COLLECTOR_KEY, messageCollector)
@@ -53,41 +58,43 @@ open class GenericReplChecker(
        KotlinCoreEnvironment.createForProduction(disposable, compilerConfiguration, EnvironmentConfigFiles.JVM_CONFIG_FILES)
    }

-    protected val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl
+    private val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl

    // "line" - is the unit of evaluation here, could in fact consists of several character lines
-    protected class LineState(
+    internal class LineState(
            val codeLine: ReplCodeLine,
            val psiFile: KtFile,
            val errorHolder: DiagnosticMessageHolder)

-    protected var lineState: LineState? = null
+    private var _lineState: LineState? = null
+
+    internal val lineState: LineState? get() = stateLock.read { _lineState }

    fun createDiagnosticHolder() = ReplTerminalDiagnosticMessageHolder()

-    @Synchronized
-    override fun check(codeLine: ReplCodeLine, history: List<ReplCodeLine>): ReplCheckResult {
-        val virtualFile =
-                LightVirtualFile("line${codeLine.no}${KotlinParserDefinition.STD_SCRIPT_EXT}", KotlinLanguage.INSTANCE, codeLine.code).apply {
-                    charset = CharsetToolkit.UTF8_CHARSET
-                }
-        val psiFile: KtFile = psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile?
-                              ?: error("Script file not analyzed at line ${codeLine.no}: ${codeLine.code}")
+    fun check(codeLine: ReplCodeLine, generation: Long): ReplCheckResult {
+        stateLock.write {
+            val scriptFileName = makeSriptBaseName(codeLine, generation)
+            val virtualFile =
+                    LightVirtualFile("${scriptFileName}${KotlinParserDefinition.STD_SCRIPT_EXT}", KotlinLanguage.INSTANCE, codeLine.code).apply {
+                        charset = CharsetToolkit.UTF8_CHARSET
+                    }
+            val psiFile: KtFile = psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile?
+                                  ?: error("Script file not analyzed at line ${codeLine.no}: ${codeLine.code}")

-        val errorHolder = createDiagnosticHolder()
+            val errorHolder = createDiagnosticHolder()

-        val syntaxErrorReport = AnalyzerWithCompilerReport.Companion.reportSyntaxErrors(psiFile, errorHolder)
+            val syntaxErrorReport = AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorHolder)

-        if (!syntaxErrorReport.isHasErrors) {
-            lineState = LineState(codeLine, psiFile, errorHolder)
-        }
+            if (!syntaxErrorReport.isHasErrors) {
+                _lineState = LineState(codeLine, psiFile, errorHolder)
+            }

-        return when {
-            syntaxErrorReport.isHasErrors && syntaxErrorReport.isAllErrorsAtEof -> ReplCheckResult.Incomplete(history)
-            syntaxErrorReport.isHasErrors -> ReplCheckResult.Error(history, errorHolder.renderedDiagnostics)
-            else -> ReplCheckResult.Ok(history)
+            return when {
+                syntaxErrorReport.isHasErrors && syntaxErrorReport.isAllErrorsAtEof -> ReplCheckResult.Incomplete()
+                syntaxErrorReport.isHasErrors -> ReplCheckResult.Error(errorHolder.renderedDiagnostics)
+                else -> ReplCheckResult.Ok()
+            }
        }
    }
 }
-
-
@@ -16,6 +16,7 @@

 package org.jetbrains.kotlin.cli.jvm.repl

+
 import com.intellij.openapi.Disposable
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.messages.MessageCollector
@@ -29,78 +30,115 @@ import org.jetbrains.kotlin.descriptors.ScriptDescriptor
 import org.jetbrains.kotlin.script.KotlinScriptDefinition
 import org.jetbrains.kotlin.script.KotlinScriptExternalDependencies
 import java.io.File
+import java.util.concurrent.atomic.AtomicLong
+import java.util.concurrent.locks.ReentrantReadWriteLock
+import kotlin.concurrent.read
+import kotlin.concurrent.write

-open class GenericReplCompiler(
-        disposable: Disposable,
-        scriptDefinition: KotlinScriptDefinition,
-        compilerConfiguration: CompilerConfiguration,
-        messageCollector: MessageCollector
-) : ReplCompiler, GenericReplChecker(disposable, scriptDefinition, compilerConfiguration, messageCollector) {
-    private val analyzerEngine = CliReplAnalyzerEngine(environment)
+open class GenericReplCompiler(disposable: Disposable,
+                               protected val scriptDefinition: KotlinScriptDefinition,
+                               protected val compilerConfiguration: CompilerConfiguration,
+                               messageCollector: MessageCollector,
+                               protected val stateLock: ReentrantReadWriteLock = ReentrantReadWriteLock()) : ReplCompiler {
+    private val checker = GenericReplChecker(disposable, scriptDefinition, compilerConfiguration, messageCollector, stateLock)
+
+    private val analyzerEngine = GenericReplAnalyzer(checker.environment, stateLock)

    private var lastDependencies: KotlinScriptExternalDependencies? = null

    private val descriptorsHistory = ReplHistory<ScriptDescriptor>()

-    @Synchronized
-    override fun compile(codeLine: ReplCodeLine, history: List<ReplCodeLine>): ReplCompileResult {
-        checkAndUpdateReplHistoryCollection(descriptorsHistory, history)?.let {
-            return@compile ReplCompileResult.HistoryMismatch(descriptorsHistory.lines, it)
-        }
+    private val generation = AtomicLong(1)

-        val (psiFile, errorHolder) = run {
-            if (lineState == null || lineState!!.codeLine != codeLine) {
-                val res = check(codeLine, history)
-                when (res) {
-                    is ReplCheckResult.Incomplete -> return@compile ReplCompileResult.Incomplete(res.updatedHistory)
-                    is ReplCheckResult.Error -> return@compile ReplCompileResult.Error(res.updatedHistory, res.message, res.location)
-                    is ReplCheckResult.Ok -> {} // continue
+    override fun resetToLine(lineNumber: Int): List<ReplCodeLine> {
+        return stateLock.write {
+            generation.incrementAndGet()
+            val removedCompiledLines = descriptorsHistory.resetToLine(lineNumber)
+            val removedAnalyzedLines = analyzerEngine.resetToLine(lineNumber)
+
+            removedCompiledLines.zip(removedAnalyzedLines).forEach {
+                if (it.first.first != it.second) {
+                    throw IllegalStateException("History mistmatch when resetting lines")
                }
            }
-            Pair(lineState!!.psiFile, lineState!!.errorHolder)
+
+            removedCompiledLines
+        }.map { it.first }
+    }
+
+    override val history: List<ReplCodeLine> get() = stateLock.read { descriptorsHistory.copySources() }
+
+    override fun check(codeLine: ReplCodeLine): ReplCheckResult {
+        return checker.check(codeLine, generation.get())
+    }
+
+    override fun compile(codeLine: ReplCodeLine, verifyHistory: List<ReplCodeLine>?): ReplCompileResult {
+        stateLock.write {
+            val firstMismatch = descriptorsHistory.firstMismatchingHistory(verifyHistory)
+            if (firstMismatch != null) {
+                return@compile ReplCompileResult.HistoryMismatch(descriptorsHistory.copySources(), firstMismatch)
+            }
+
+            val currentGeneration = generation.get()
+
+            val (psiFile, errorHolder) = run {
+                if (checker.lineState == null || checker.lineState!!.codeLine != codeLine) {
+                    val res = checker.check(codeLine, currentGeneration)
+                    when (res) {
+                        is ReplCheckResult.Incomplete -> return@compile ReplCompileResult.Incomplete(descriptorsHistory.copySources())
+                        is ReplCheckResult.Error -> return@compile ReplCompileResult.Error(descriptorsHistory.copySources(), res.message, res.location)
+                        is ReplCheckResult.Ok -> NO_ACTION()
+                    }
+                }
+                Pair(checker.lineState!!.psiFile, checker.lineState!!.errorHolder)
+            }
+
+            val newDependencies = scriptDefinition.getDependenciesFor(psiFile, checker.environment.project, lastDependencies)
+            var classpathAddendum: List<File>? = null
+            if (lastDependencies != newDependencies) {
+                lastDependencies = newDependencies
+                classpathAddendum = newDependencies?.let { checker.environment.updateClasspath(it.classpath.map(::JvmClasspathRoot)) }
+            }
+
+            val analysisResult = analyzerEngine.analyzeReplLine(psiFile, codeLine)
+            AnalyzerWithCompilerReport.reportDiagnostics(analysisResult.diagnostics, errorHolder)
+            val scriptDescriptor = when (analysisResult) {
+                is GenericReplAnalyzer.ReplLineAnalysisResult.WithErrors -> return ReplCompileResult.Error(descriptorsHistory.copySources(), errorHolder.renderedDiagnostics)
+                is GenericReplAnalyzer.ReplLineAnalysisResult.Successful -> analysisResult.scriptDescriptor
+                else -> error("Unexpected result ${analysisResult.javaClass}")
+            }
+
+            val state = GenerationState(
+                    psiFile.project,
+                    ClassBuilderFactories.binaries(false),
+                    analyzerEngine.module,
+                    analyzerEngine.trace.bindingContext,
+                    listOf(psiFile),
+                    compilerConfiguration
+            )
+            state.replSpecific.scriptResultFieldName = SCRIPT_RESULT_FIELD_NAME
+            state.replSpecific.earlierScriptsForReplInterpreter = descriptorsHistory.copyValues()
+            state.beforeCompile()
+            KotlinCodegenFacade.generatePackage(
+                    state,
+                    psiFile.script!!.getContainingKtFile().packageFqName,
+                    setOf(psiFile.script!!.getContainingKtFile()),
+                    org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION)
+
+            val generatedClassname = makeSriptBaseName(codeLine, currentGeneration)
+            val compiledCodeLine = CompiledReplCodeLine(generatedClassname, codeLine)
+            descriptorsHistory.add(compiledCodeLine, scriptDescriptor)
+
+            return ReplCompileResult.CompiledClasses(descriptorsHistory.copySources(),
+                                                     compiledCodeLine,
+                                                     generatedClassname,
+                                                     state.factory.asList().map { CompiledClassData(it.relativePath, it.asByteArray()) },
+                                                     state.replSpecific.hasResult,
+                                                       classpathAddendum ?: emptyList())
        }
-
-        val newDependencies = scriptDefinition.getDependenciesFor(psiFile, environment.project, lastDependencies)
-        var classpathAddendum: List<File>? = null
-        if (lastDependencies != newDependencies) {
-            lastDependencies = newDependencies
-            classpathAddendum = newDependencies?.let { environment.updateClasspath(it.classpath.map(::JvmClasspathRoot)) }
-        }
-
-        val analysisResult = analyzerEngine.analyzeReplLine(psiFile, codeLine.no)
-        AnalyzerWithCompilerReport.Companion.reportDiagnostics(analysisResult.diagnostics, errorHolder)
-        val scriptDescriptor = when (analysisResult) {
-            is CliReplAnalyzerEngine.ReplLineAnalysisResult.WithErrors -> return ReplCompileResult.Error(descriptorsHistory.lines, errorHolder.renderedDiagnostics)
-            is CliReplAnalyzerEngine.ReplLineAnalysisResult.Successful -> analysisResult.scriptDescriptor
-            else -> error("Unexpected result ${analysisResult.javaClass}")
-        }
-
-        val state = GenerationState(
-                psiFile.project,
-                ClassBuilderFactories.binaries(false),
-                analyzerEngine.module,
-                analyzerEngine.trace.bindingContext,
-                listOf(psiFile),
-                compilerConfiguration
-        )
-        state.replSpecific.scriptResultFieldName = SCRIPT_RESULT_FIELD_NAME
-        state.replSpecific.earlierScriptsForReplInterpreter = descriptorsHistory.values
-        state.beforeCompile()
-        KotlinCodegenFacade.generatePackage(
-                state,
-                psiFile.script!!.getContainingKtFile().packageFqName,
-                setOf(psiFile.script!!.getContainingKtFile()),
-                org.jetbrains.kotlin.codegen.CompilationErrorHandler.THROW_EXCEPTION)
-
-        descriptorsHistory.add(codeLine, scriptDescriptor)
-
-        return ReplCompileResult.CompiledClasses(descriptorsHistory.lines,
-                                                 state.factory.asList().map { CompiledClassData(it.relativePath, it.asByteArray()) },
-                                                 state.replSpecific.hasResult,
-                                                 classpathAddendum ?: emptyList())
    }

    companion object {
        private val SCRIPT_RESULT_FIELD_NAME = "\$\$result"
    }
-}
+}
@@ -24,11 +24,10 @@ import com.intellij.psi.impl.PsiFileFactoryImpl
 import com.intellij.testFramework.LightVirtualFile
 import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport
 import org.jetbrains.kotlin.cli.common.repl.ReplClassLoader
+import org.jetbrains.kotlin.cli.common.repl.ReplCodeLine
 import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
 import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment
 import org.jetbrains.kotlin.cli.jvm.config.jvmClasspathRoots
-import org.jetbrains.kotlin.cli.jvm.repl.CliReplAnalyzerEngine.ReplLineAnalysisResult.Successful
-import org.jetbrains.kotlin.cli.jvm.repl.CliReplAnalyzerEngine.ReplLineAnalysisResult.WithErrors
 import org.jetbrains.kotlin.codegen.ClassBuilderFactories
 import org.jetbrains.kotlin.codegen.CompilationErrorHandler
 import org.jetbrains.kotlin.codegen.KotlinCodegenFacade
@@ -65,7 +64,7 @@ class ReplInterpreter(
    }

    private val psiFileFactory: PsiFileFactoryImpl = PsiFileFactory.getInstance(environment.project) as PsiFileFactoryImpl
-    private val analyzerEngine = CliReplAnalyzerEngine(environment)
+    private val analyzerEngine = GenericReplAnalyzer(environment)

    fun eval(line: String): LineResult {
        ++lineNumber
@@ -99,11 +98,11 @@ class ReplInterpreter(
            return LineResult.Error.CompileTime(errorHolder.renderedDiagnostics)
        }

-        val analysisResult = analyzerEngine.analyzeReplLine(psiFile, lineNumber)
+        val analysisResult = analyzerEngine.analyzeReplLine(psiFile, ReplCodeLine(lineNumber, "fake line"))
        AnalyzerWithCompilerReport.reportDiagnostics(analysisResult.diagnostics, errorHolder)
        val scriptDescriptor = when (analysisResult) {
-            is WithErrors -> return LineResult.Error.CompileTime(errorHolder.renderedDiagnostics)
-            is Successful -> analysisResult.scriptDescriptor
+            is GenericReplAnalyzer.ReplLineAnalysisResult.WithErrors -> return LineResult.Error.CompileTime(errorHolder.renderedDiagnostics)
+            is GenericReplAnalyzer.ReplLineAnalysisResult.Successful -> analysisResult.scriptDescriptor
            else -> error("Unexpected result ${analysisResult.javaClass}")
        }