From 5670e7f75004b9554c46e6eeb804e5bf83c44c83 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Wed, 3 Feb 2016 09:39:00 +0530 Subject: [PATCH] J2K ReplInterpreter: convert --- .../kotlin/cli/jvm/repl/ReplInterpreter.kt | 680 ++++++++---------- 1 file changed, 310 insertions(+), 370 deletions(-) diff --git a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.kt b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.kt index c30275fa601..b4c4e290848 100644 --- a/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.kt +++ b/compiler/cli/src/org/jetbrains/kotlin/cli/jvm/repl/ReplInterpreter.kt @@ -14,505 +14,445 @@ * limitations under the License. */ -package org.jetbrains.kotlin.cli.jvm.repl; +package org.jetbrains.kotlin.cli.jvm.repl -import com.google.common.base.Throwables; -import com.google.common.collect.Lists; -import com.intellij.openapi.Disposable; -import com.intellij.openapi.project.Project; -import com.intellij.openapi.vfs.CharsetToolkit; -import com.intellij.psi.PsiFile; -import com.intellij.psi.PsiFileFactory; -import com.intellij.psi.impl.PsiFileFactoryImpl; -import com.intellij.psi.search.ProjectScope; -import com.intellij.testFramework.LightVirtualFile; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; -import org.jetbrains.kotlin.backend.common.output.OutputFile; -import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport; -import org.jetbrains.kotlin.cli.common.messages.DiagnosticMessageReporter; -import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport; -import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles; -import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider; -import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment; -import org.jetbrains.kotlin.cli.jvm.config.JvmContentRootsKt; -import org.jetbrains.kotlin.cli.jvm.config.ModuleNameKt; -import org.jetbrains.kotlin.cli.jvm.repl.di.ContainerForReplWithJava; -import org.jetbrains.kotlin.cli.jvm.repl.di.InjectionKt; -import org.jetbrains.kotlin.cli.jvm.repl.di.ReplLastLineScopeProvider; -import org.jetbrains.kotlin.cli.jvm.repl.messages.DiagnosticMessageHolder; -import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplIdeDiagnosticMessageHolder; -import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplSystemInWrapper; -import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplTerminalDiagnosticMessageHolder; -import org.jetbrains.kotlin.codegen.ClassBuilderFactories; -import org.jetbrains.kotlin.codegen.CompilationErrorHandler; -import org.jetbrains.kotlin.codegen.KotlinCodegenFacade; -import org.jetbrains.kotlin.codegen.state.GenerationState; -import org.jetbrains.kotlin.config.CommonConfigurationKeys; -import org.jetbrains.kotlin.config.CompilerConfiguration; -import org.jetbrains.kotlin.context.MutableModuleContext; -import org.jetbrains.kotlin.descriptors.ScriptDescriptor; -import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider; -import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl; -import org.jetbrains.kotlin.idea.KotlinLanguage; -import org.jetbrains.kotlin.name.FqName; -import org.jetbrains.kotlin.name.Name; -import org.jetbrains.kotlin.parsing.KotlinParserDefinition; -import org.jetbrains.kotlin.psi.KtFile; -import org.jetbrains.kotlin.psi.KtScript; -import org.jetbrains.kotlin.resolve.*; -import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory; -import org.jetbrains.kotlin.resolve.jvm.JvmClassName; -import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM; -import org.jetbrains.kotlin.resolve.lazy.ResolveSession; -import org.jetbrains.kotlin.resolve.lazy.data.KtClassLikeInfo; -import org.jetbrains.kotlin.resolve.lazy.declarations.*; -import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyScriptDescriptor; -import org.jetbrains.kotlin.resolve.scopes.LexicalScope; -import org.jetbrains.kotlin.script.*; -import org.jetbrains.kotlin.utils.ExceptionUtilsKt; +import com.google.common.base.Throwables +import com.google.common.collect.Lists +import com.intellij.openapi.Disposable +import com.intellij.openapi.project.Project +import com.intellij.openapi.vfs.CharsetToolkit +import com.intellij.psi.PsiFile +import com.intellij.psi.PsiFileFactory +import com.intellij.psi.impl.PsiFileFactoryImpl +import com.intellij.psi.search.ProjectScope +import com.intellij.testFramework.LightVirtualFile +import org.jetbrains.kotlin.backend.common.output.OutputFile +import org.jetbrains.kotlin.cli.common.messages.AnalyzerWithCompilerReport +import org.jetbrains.kotlin.cli.common.messages.DiagnosticMessageReporter +import org.jetbrains.kotlin.cli.jvm.compiler.CliLightClassGenerationSupport +import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles +import org.jetbrains.kotlin.cli.jvm.compiler.JvmPackagePartProvider +import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment +import org.jetbrains.kotlin.cli.jvm.config.* +import org.jetbrains.kotlin.cli.jvm.config.* +import org.jetbrains.kotlin.cli.jvm.repl.di.ContainerForReplWithJava +import org.jetbrains.kotlin.cli.jvm.repl.di.* +import org.jetbrains.kotlin.cli.jvm.repl.di.ReplLastLineScopeProvider +import org.jetbrains.kotlin.cli.jvm.repl.messages.DiagnosticMessageHolder +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplIdeDiagnosticMessageHolder +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplSystemInWrapper +import org.jetbrains.kotlin.cli.jvm.repl.messages.ReplTerminalDiagnosticMessageHolder +import org.jetbrains.kotlin.codegen.ClassBuilderFactories +import org.jetbrains.kotlin.codegen.CompilationErrorHandler +import org.jetbrains.kotlin.codegen.KotlinCodegenFacade +import org.jetbrains.kotlin.codegen.state.GenerationState +import org.jetbrains.kotlin.config.CommonConfigurationKeys +import org.jetbrains.kotlin.config.CompilerConfiguration +import org.jetbrains.kotlin.context.MutableModuleContext +import org.jetbrains.kotlin.descriptors.ScriptDescriptor +import org.jetbrains.kotlin.descriptors.impl.CompositePackageFragmentProvider +import org.jetbrains.kotlin.descriptors.impl.ModuleDescriptorImpl +import org.jetbrains.kotlin.idea.KotlinLanguage +import org.jetbrains.kotlin.name.FqName +import org.jetbrains.kotlin.name.Name +import org.jetbrains.kotlin.parsing.KotlinParserDefinition +import org.jetbrains.kotlin.psi.KtFile +import org.jetbrains.kotlin.psi.KtScript +import org.jetbrains.kotlin.resolve.* +import org.jetbrains.kotlin.resolve.calls.smartcasts.DataFlowInfoFactory +import org.jetbrains.kotlin.resolve.jvm.JvmClassName +import org.jetbrains.kotlin.resolve.jvm.TopDownAnalyzerFacadeForJVM +import org.jetbrains.kotlin.resolve.lazy.ResolveSession +import org.jetbrains.kotlin.resolve.lazy.data.KtClassLikeInfo +import org.jetbrains.kotlin.resolve.lazy.declarations.* +import org.jetbrains.kotlin.resolve.lazy.descriptors.LazyScriptDescriptor +import org.jetbrains.kotlin.resolve.scopes.LexicalScope +import org.jetbrains.kotlin.script.* +import org.jetbrains.kotlin.utils.* -import java.io.File; -import java.io.PrintWriter; -import java.lang.reflect.Constructor; -import java.lang.reflect.Field; -import java.net.MalformedURLException; -import java.net.URL; -import java.net.URLClassLoader; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.List; +import java.io.File +import java.io.PrintWriter +import java.lang.reflect.Constructor +import java.lang.reflect.Field +import java.net.MalformedURLException +import java.net.URL +import java.net.URLClassLoader +import java.util.ArrayList +import java.util.Arrays +import java.util.Collections -public class ReplInterpreter { - private static final String SCRIPT_RESULT_FIELD_NAME = "$$result"; +class ReplInterpreter( + disposable: Disposable, + configuration: CompilerConfiguration, + private val ideMode: Boolean, + private val replReader: ReplSystemInWrapper?) { - private int lineNumber = 0; + private var lineNumber = 0 - @Nullable - private LexicalScope lastLineScope; - private final List earlierLines = Lists.newArrayList(); - private final List previousIncompleteLines = Lists.newArrayList(); - private final ReplClassLoader classLoader; + private var lastLineScope: LexicalScope? = null + private val earlierLines = Lists.newArrayList() + private val previousIncompleteLines = Lists.newArrayList() + private val classLoader: ReplClassLoader - private final PsiFileFactoryImpl psiFileFactory; - private final BindingTraceContext trace; - private final ModuleDescriptorImpl module; + private val psiFileFactory: PsiFileFactoryImpl + private val trace: BindingTraceContext + private val module: ModuleDescriptorImpl - private final TopDownAnalysisContext topDownAnalysisContext; - private final LazyTopDownAnalyzerForTopLevel topDownAnalyzer; - private final ResolveSession resolveSession; - private final ScriptMutableDeclarationProviderFactory scriptDeclarationFactory; + private val topDownAnalysisContext: TopDownAnalysisContext + private val topDownAnalyzer: LazyTopDownAnalyzerForTopLevel + private val resolveSession: ResolveSession + private val scriptDeclarationFactory: ScriptMutableDeclarationProviderFactory - private final boolean ideMode; - private final ReplSystemInWrapper replReader; - private final static KotlinScriptDefinition REPL_LINE_AS_SCRIPT_DEFINITION = new KotlinScriptDefinition() { - @NotNull - @Override - public List getScriptParameters(@NotNull ScriptDescriptor scriptDescriptor) { - return Collections.emptyList(); - } + init { + configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, REPL_LINE_AS_SCRIPT_DEFINITION) - @Override - public boolean isScript(@NotNull PsiFile file) { - return StandardScriptDefinition.INSTANCE.isScript(file); - } + val environment = KotlinCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES) + val project = environment.project - @NotNull - @Override - public Name getScriptName(@NotNull KtScript script) { - return StandardScriptDefinition.INSTANCE.getScriptName(script); - } - }; + this.psiFileFactory = PsiFileFactory.getInstance(project) as PsiFileFactoryImpl + this.trace = CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace() + val moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, environment.getModuleName()) + this.module = moduleContext.module - public ReplInterpreter( - @NotNull Disposable disposable, - @NotNull CompilerConfiguration configuration, - boolean ideMode, - @Nullable ReplSystemInWrapper replReader - ) { - configuration.add(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY, REPL_LINE_AS_SCRIPT_DEFINITION); + scriptDeclarationFactory = ScriptMutableDeclarationProviderFactory() - KotlinCoreEnvironment environment = - KotlinCoreEnvironment.createForProduction(disposable, configuration, EnvironmentConfigFiles.JVM_CONFIG_FILES); - Project project = environment.getProject(); - - this.psiFileFactory = (PsiFileFactoryImpl) PsiFileFactory.getInstance(project); - this.trace = new CliLightClassGenerationSupport.NoScopeRecordCliBindingTrace(); - MutableModuleContext moduleContext = TopDownAnalyzerFacadeForJVM.createContextWithSealedModule(project, ModuleNameKt - .getModuleName(environment)); - this.module = moduleContext.getModule(); - - scriptDeclarationFactory = new ScriptMutableDeclarationProviderFactory(); - - ContainerForReplWithJava container = InjectionKt.createContainerForReplWithJava( + val container = createContainerForReplWithJava( moduleContext, trace, scriptDeclarationFactory, ProjectScope.getAllScope(project), - new ReplLastLineScopeProvider() { - @Nullable - @Override - public LexicalScope getLastLineScope() { - return lastLineScope; - } + object : ReplLastLineScopeProvider { + override val lastLineScope: LexicalScope? + get() = lastLineScope }, - new JvmPackagePartProvider(environment) - ); + JvmPackagePartProvider(environment)) - this.topDownAnalysisContext = new TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfoFactory.EMPTY, - container.getResolveSession().getDeclarationScopeProvider()); - this.topDownAnalyzer = container.getLazyTopDownAnalyzerForTopLevel(); - this.resolveSession = container.getResolveSession(); + this.topDownAnalysisContext = TopDownAnalysisContext(TopDownAnalysisMode.LocalDeclarations, DataFlowInfoFactory.EMPTY, + container.resolveSession.declarationScopeProvider) + this.topDownAnalyzer = container.lazyTopDownAnalyzerForTopLevel + this.resolveSession = container.resolveSession - moduleContext.initializeModuleContents(new CompositePackageFragmentProvider( + moduleContext.initializeModuleContents(CompositePackageFragmentProvider( Arrays.asList( - container.getResolveSession().getPackageFragmentProvider(), - container.getJavaDescriptorResolver().getPackageFragmentProvider() - ) - )); + container.resolveSession.packageFragmentProvider, + container.javaDescriptorResolver.packageFragmentProvider))) - List classpath = Lists.newArrayList(); - for (File file : JvmContentRootsKt.getJvmClasspathRoots(configuration)) { + val classpath = Lists.newArrayList() + for (file in configuration.jvmClasspathRoots) { try { - classpath.add(file.toURI().toURL()); + classpath.add(file.toURI().toURL()) } - catch (MalformedURLException e) { - throw ExceptionUtilsKt.rethrow(e); + catch (e: MalformedURLException) { + throw rethrow(e) } + } - this.classLoader = new ReplClassLoader(new URLClassLoader(classpath.toArray(new URL[classpath.size()]), null)); - - this.ideMode = ideMode; - this.replReader = replReader; + this.classLoader = ReplClassLoader(URLClassLoader(classpath.toArray(arrayOfNulls(classpath.size)), null)) } - private static void prepareForTheNextReplLine(@NotNull TopDownAnalysisContext c) { - c.getScripts().clear(); - } - - public enum LineResultType { + enum class LineResultType { SUCCESS, COMPILE_ERROR, RUNTIME_ERROR, - INCOMPLETE, + INCOMPLETE } - public static class LineResult { - private final Object value; - private final boolean unit; - private final String errorText; - private final LineResultType type; + class LineResult private constructor(private val value: Any?, private val unit: Boolean, val errorText: String?, val type: LineResultType) { - private LineResult(Object value, boolean unit, String errorText, @NotNull LineResultType type) { - this.value = value; - this.unit = unit; - this.errorText = errorText; - this.type = type; - } - - @NotNull - public LineResultType getType() { - return type; - } - - private void checkSuccessful() { - if (getType() != LineResultType.SUCCESS) { - throw new IllegalStateException("it is error"); + private fun checkSuccessful() { + if (type != LineResultType.SUCCESS) { + throw IllegalStateException("it is error") } } - public Object getValue() { - checkSuccessful(); - return value; + fun getValue(): Any? { + checkSuccessful() + return value } - public boolean isUnit() { - checkSuccessful(); - return unit; - } - - @NotNull - public String getErrorText() { - return errorText; - } - - @NotNull - private static LineResult error(@NotNull String errorText, @NotNull LineResultType errorType) { - if (errorText.isEmpty()) { - errorText = ""; - } - else if (!errorText.endsWith("\n")) { - errorText += "\n"; + val isUnit: Boolean + get() { + checkSuccessful() + return unit } - return new LineResult(null, false, errorText, errorType); - } + companion object { - @NotNull - public static LineResult successful(Object value, boolean unit) { - return new LineResult(value, unit, null, LineResultType.SUCCESS); - } + private fun error(errorText: String, errorType: LineResultType): LineResult { + var errorText = errorText + if (errorText.isEmpty()) { + errorText = "" + } + else if (!errorText.endsWith("\n")) { + errorText += "\n" + } - @NotNull - public static LineResult compileError(@NotNull String errorText) { - return error(errorText, LineResultType.COMPILE_ERROR); - } + return LineResult(null, false, errorText, errorType) + } - @NotNull - public static LineResult runtimeError(@NotNull String errorText) { - return error(errorText, LineResultType.RUNTIME_ERROR); - } + fun successful(value: Any, unit: Boolean): LineResult { + return LineResult(value, unit, null, LineResultType.SUCCESS) + } - public static LineResult incomplete() { - return new LineResult(null, false, null, LineResultType.INCOMPLETE); + fun compileError(errorText: String): LineResult { + return error(errorText, LineResultType.COMPILE_ERROR) + } + + fun runtimeError(errorText: String): LineResult { + return error(errorText, LineResultType.RUNTIME_ERROR) + } + + fun incomplete(): LineResult { + return LineResult(null, false, null, LineResultType.INCOMPLETE) + } } } - @NotNull - private DiagnosticMessageHolder createDiagnosticHolder() { - return ideMode ? new ReplIdeDiagnosticMessageHolder() - : new ReplTerminalDiagnosticMessageHolder(); + private fun createDiagnosticHolder(): DiagnosticMessageHolder { + return if (ideMode) + ReplIdeDiagnosticMessageHolder() + else + ReplTerminalDiagnosticMessageHolder() } - @NotNull - public LineResult eval(@NotNull String line) { - ++lineNumber; + fun eval(line: String): LineResult { + ++lineNumber - FqName scriptFqName = new FqName("Line" + lineNumber); + val scriptFqName = FqName("Line" + lineNumber) - StringBuilder fullText = new StringBuilder(); - for (String prevLine : previousIncompleteLines) { - fullText.append(prevLine).append("\n"); + val fullText = StringBuilder() + for (prevLine in previousIncompleteLines) { + fullText.append(prevLine).append("\n") } - fullText.append(line); + fullText.append(line) - LightVirtualFile virtualFile = new LightVirtualFile("line" + lineNumber + KotlinParserDefinition.STD_SCRIPT_EXT, KotlinLanguage.INSTANCE, fullText.toString()); - virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET); - KtFile psiFile = (KtFile) psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false); - assert psiFile != null : "Script file not analyzed at line " + lineNumber + ": " + fullText; + val virtualFile = LightVirtualFile("line" + lineNumber + KotlinParserDefinition.STD_SCRIPT_EXT, KotlinLanguage.INSTANCE, fullText.toString()) + virtualFile.setCharset(CharsetToolkit.UTF8_CHARSET) + val psiFile = psiFileFactory.trySetupPsiForFile(virtualFile, KotlinLanguage.INSTANCE, true, false) as KtFile? ?: error("Script file not analyzed at line $lineNumber: $fullText") - DiagnosticMessageHolder errorHolder = createDiagnosticHolder(); + val errorHolder = createDiagnosticHolder() - AnalyzerWithCompilerReport.SyntaxErrorReport syntaxErrorReport = AnalyzerWithCompilerReport.Companion - .reportSyntaxErrors(psiFile, errorHolder); + val syntaxErrorReport = AnalyzerWithCompilerReport.reportSyntaxErrors(psiFile, errorHolder) - if (syntaxErrorReport.isHasErrors() && syntaxErrorReport.isAllErrorsAtEof()) { + if (syntaxErrorReport.isHasErrors && syntaxErrorReport.isAllErrorsAtEof) { if (ideMode) { - return LineResult.compileError(errorHolder.getRenderedDiagnostics()); + return LineResult.compileError(errorHolder.renderedDiagnostics) } else { - previousIncompleteLines.add(line); - return LineResult.incomplete(); + previousIncompleteLines.add(line) + return LineResult.incomplete() } } - previousIncompleteLines.clear(); + previousIncompleteLines.clear() - if (syntaxErrorReport.isHasErrors()) { - return LineResult.compileError(errorHolder.getRenderedDiagnostics()); + if (syntaxErrorReport.isHasErrors) { + return LineResult.compileError(errorHolder.renderedDiagnostics) } - prepareForTheNextReplLine(topDownAnalysisContext); - trace.clearDiagnostics(); + prepareForTheNextReplLine(topDownAnalysisContext) + trace.clearDiagnostics() //noinspection ConstantConditions - psiFile.getScript().putUserData(ScriptPriorities.PRIORITY_KEY, lineNumber); + psiFile!!.script!!.putUserData(ScriptPriorities.PRIORITY_KEY, lineNumber) - ScriptDescriptor scriptDescriptor = doAnalyze(psiFile, errorHolder); - if (scriptDescriptor == null) { - return LineResult.compileError(errorHolder.getRenderedDiagnostics()); + val scriptDescriptor = doAnalyze(psiFile, errorHolder) ?: return LineResult.compileError(errorHolder.renderedDiagnostics) + + val earlierScripts = Lists.newArrayList() + + for (earlierLine in earlierLines) { + earlierScripts.add(earlierLine.scriptDescriptor) } - List earlierScripts = Lists.newArrayList(); + val state = GenerationState(psiFile.project, ClassBuilderFactories.BINARIES, + module, trace.bindingContext, listOf(psiFile)) - for (EarlierLine earlierLine : earlierLines) { - earlierScripts.add(earlierLine.getScriptDescriptor()); - } + compileScript(psiFile.script!!, earlierScripts, state, CompilationErrorHandler.THROW_EXCEPTION) - GenerationState state = new GenerationState(psiFile.getProject(), ClassBuilderFactories.BINARIES, - module, trace.getBindingContext(), Collections.singletonList(psiFile)); - - compileScript(psiFile.getScript(), earlierScripts, state, CompilationErrorHandler.THROW_EXCEPTION); - - for (OutputFile outputFile : state.getFactory().asList()) { - if(outputFile.getRelativePath().endsWith(".class")) { - classLoader.addClass(JvmClassName.byInternalName(outputFile.getRelativePath().replaceFirst("\\.class$", "")), - outputFile.asByteArray()); + for (outputFile in state.factory.asList()) { + if (outputFile.relativePath.endsWith(".class")) { + classLoader.addClass(JvmClassName.byInternalName(outputFile.relativePath.replaceFirst("\\.class$".toRegex(), "")), + outputFile.asByteArray()) } } try { - Class scriptClass = classLoader.loadClass(scriptFqName.asString()); + val scriptClass = classLoader.loadClass(scriptFqName.asString()) - Class[] constructorParams = new Class[earlierLines.size()]; - Object[] constructorArgs = new Object[earlierLines.size()]; + val constructorParams = arrayOfNulls>(earlierLines.size) + val constructorArgs = arrayOfNulls(earlierLines.size) - for (int i = 0; i < earlierLines.size(); ++i) { - constructorParams[i] = earlierLines.get(i).getScriptClass(); - constructorArgs[i] = earlierLines.get(i).getScriptInstance(); + for (i in earlierLines.indices) { + constructorParams[i] = earlierLines[i].scriptClass + constructorArgs[i] = earlierLines[i].scriptInstance } - Constructor scriptInstanceConstructor = scriptClass.getConstructor(constructorParams); - Object scriptInstance; + val scriptInstanceConstructor = scriptClass.getConstructor(*constructorParams) + val scriptInstance: Any try { - setReplScriptExecuting(true); - scriptInstance = scriptInstanceConstructor.newInstance(constructorArgs); + setReplScriptExecuting(true) + scriptInstance = scriptInstanceConstructor.newInstance(*constructorArgs) } - catch (Throwable e) { - return LineResult.runtimeError(renderStackTrace(e.getCause())); - } finally { - setReplScriptExecuting(false); + catch (e: Throwable) { + return LineResult.runtimeError(renderStackTrace(e.cause!!)) + } + finally { + setReplScriptExecuting(false) } - Field rvField = scriptClass.getDeclaredField(SCRIPT_RESULT_FIELD_NAME); - rvField.setAccessible(true); - Object rv = rvField.get(scriptInstance); + val rvField = scriptClass.getDeclaredField(SCRIPT_RESULT_FIELD_NAME) + rvField.isAccessible = true + val rv = rvField.get(scriptInstance) - earlierLines.add(new EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance)); + earlierLines.add(EarlierLine(line, scriptDescriptor, scriptClass, scriptInstance)) - return LineResult.successful(rv, !state.getReplSpecific().getHasResult()); + return LineResult.successful(rv, !state.replSpecific.hasResult) } - catch (Throwable e) { + catch (e: Throwable) { @SuppressWarnings("UseOfSystemOutOrSystemErr") - PrintWriter writer = new PrintWriter(System.err); - classLoader.dumpClasses(writer); - writer.flush(); - throw ExceptionUtilsKt.rethrow(e); + val writer = PrintWriter(System.err) + classLoader.dumpClasses(writer) + writer.flush() + throw rethrow(e) } + } - private void setReplScriptExecuting(boolean isExecuting) { + private fun setReplScriptExecuting(isExecuting: Boolean) { if (replReader != null) { - replReader.setReplScriptExecuting(isExecuting); + replReader.isReplScriptExecuting = isExecuting } } - @NotNull - private static String renderStackTrace(@NotNull Throwable cause) { - StackTraceElement[] oldTrace = cause.getStackTrace(); - List newTrace = new ArrayList(); - boolean skip = true; - for (int i = oldTrace.length - 1; i >= 0; i--) { - StackTraceElement element = oldTrace[i]; - // All our code happens in the script constructor, and no reflection/native code happens in constructors. - // So we ignore everything in the stack trace until the first constructor - if (element.getMethodName().equals("")) { - skip = false; - } - if (!skip) { - newTrace.add(element); - } - } - Collections.reverse(newTrace); - - // throw away last element which contains Line1.kts(Unknown source) - List resultingTrace = newTrace.subList(0, newTrace.size() - 1); - - cause.setStackTrace(resultingTrace.toArray(new StackTraceElement[resultingTrace.size()])); - return Throwables.getStackTraceAsString(cause); - } - - @Nullable - private ScriptDescriptor doAnalyze(@NotNull KtFile psiFile, @NotNull DiagnosticMessageReporter errorReporter) { + private fun doAnalyze(psiFile: KtFile, errorReporter: DiagnosticMessageReporter): ScriptDescriptor? { scriptDeclarationFactory.setDelegateFactory( - new FileBasedDeclarationProviderFactory(resolveSession.getStorageManager(), Collections.singletonList(psiFile))); + FileBasedDeclarationProviderFactory(resolveSession.storageManager, listOf(psiFile))) - TopDownAnalysisContext context = topDownAnalyzer.analyzeDeclarations( - topDownAnalysisContext.getTopDownAnalysisMode(), - Collections.singletonList(psiFile) - ); + val context = topDownAnalyzer.analyzeDeclarations( + topDownAnalysisContext.topDownAnalysisMode, + listOf(psiFile)) if (trace.get(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile) == null) { - trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, resolveSession.getPackageFragment(FqName.ROOT)); + trace.record(BindingContext.FILE_TO_PACKAGE_FRAGMENT, psiFile, resolveSession.getPackageFragment(FqName.ROOT)) } - boolean hasErrors = AnalyzerWithCompilerReport.Companion - .reportDiagnostics(trace.getBindingContext().getDiagnostics(), errorReporter, false); + val hasErrors = AnalyzerWithCompilerReport.reportDiagnostics(trace.bindingContext.diagnostics, errorReporter, false) if (hasErrors) { - return null; + return null } - LazyScriptDescriptor scriptDescriptor = context.getScripts().get(psiFile.getScript()); - lastLineScope = scriptDescriptor.getScopeForInitializerResolution(); - return scriptDescriptor; + val scriptDescriptor = context.scripts[psiFile.script]!! + lastLineScope = scriptDescriptor.getScopeForInitializerResolution() + return scriptDescriptor } - public void dumpClasses(@NotNull PrintWriter out) { - classLoader.dumpClasses(out); + fun dumpClasses(out: PrintWriter) { + classLoader.dumpClasses(out) } - public static void compileScript( - @NotNull KtScript script, - @NotNull List earlierScripts, - @NotNull GenerationState state, - @NotNull CompilationErrorHandler errorHandler - ) { - state.getReplSpecific().setScriptResultFieldName(SCRIPT_RESULT_FIELD_NAME); - state.getReplSpecific().setEarlierScriptsForReplInterpreter(new ArrayList(earlierScripts)); + private class ScriptMutableDeclarationProviderFactory : DeclarationProviderFactory { + private var delegateFactory: DeclarationProviderFactory? = null + private var rootPackageProvider: AdaptablePackageMemberDeclarationProvider? = null - state.beforeCompile(); - KotlinCodegenFacade.generatePackage( - state, - script.getContainingKtFile().getPackageFqName(), - Collections.singleton(script.getContainingKtFile()), - errorHandler - ); - } + fun setDelegateFactory(delegateFactory: DeclarationProviderFactory) { + this.delegateFactory = delegateFactory - private static class ScriptMutableDeclarationProviderFactory implements DeclarationProviderFactory { - private DeclarationProviderFactory delegateFactory; - private AdaptablePackageMemberDeclarationProvider rootPackageProvider; - - public void setDelegateFactory(DeclarationProviderFactory delegateFactory) { - this.delegateFactory = delegateFactory; - - PackageMemberDeclarationProvider provider = delegateFactory.getPackageMemberDeclarationProvider(FqName.ROOT); + val provider = delegateFactory.getPackageMemberDeclarationProvider(FqName.ROOT)!! if (rootPackageProvider == null) { - assert provider != null; - rootPackageProvider = new AdaptablePackageMemberDeclarationProvider(provider); + rootPackageProvider = AdaptablePackageMemberDeclarationProvider(provider) } else { - rootPackageProvider.addDelegateProvider(provider); + rootPackageProvider!!.addDelegateProvider(provider) } } - @NotNull - @Override - public ClassMemberDeclarationProvider getClassMemberDeclarationProvider(@NotNull KtClassLikeInfo classLikeInfo) { - return delegateFactory.getClassMemberDeclarationProvider(classLikeInfo); + override fun getClassMemberDeclarationProvider(classLikeInfo: KtClassLikeInfo): ClassMemberDeclarationProvider { + return delegateFactory!!.getClassMemberDeclarationProvider(classLikeInfo) } - @Nullable - @Override - public PackageMemberDeclarationProvider getPackageMemberDeclarationProvider(@NotNull FqName packageFqName) { - if (packageFqName.isRoot()) { - return rootPackageProvider; + override fun getPackageMemberDeclarationProvider(packageFqName: FqName): PackageMemberDeclarationProvider? { + if (packageFqName.isRoot) { + return rootPackageProvider } - return this.delegateFactory.getPackageMemberDeclarationProvider(packageFqName); + return this.delegateFactory!!.getPackageMemberDeclarationProvider(packageFqName) } - @Override - public void diagnoseMissingPackageFragment(KtFile file) { - this.delegateFactory.diagnoseMissingPackageFragment(file); + override fun diagnoseMissingPackageFragment(file: KtFile) { + this.delegateFactory!!.diagnoseMissingPackageFragment(file) } - public static class AdaptablePackageMemberDeclarationProvider extends DelegatePackageMemberDeclarationProvider { - @NotNull - private PackageMemberDeclarationProvider delegateProvider; + class AdaptablePackageMemberDeclarationProvider(private var delegateProvider: PackageMemberDeclarationProvider) : DelegatePackageMemberDeclarationProvider(delegateProvider) { - public AdaptablePackageMemberDeclarationProvider(@NotNull PackageMemberDeclarationProvider delegateProvider) { - super(delegateProvider); - this.delegateProvider = delegateProvider; + fun addDelegateProvider(provider: PackageMemberDeclarationProvider) { + delegateProvider = CombinedPackageMemberDeclarationProvider(Lists.newArrayList(provider, delegateProvider)) + + delegate = delegateProvider + } + } + } + + companion object { + private val SCRIPT_RESULT_FIELD_NAME = "\$\$result" + private val REPL_LINE_AS_SCRIPT_DEFINITION = object : KotlinScriptDefinition { + override fun getScriptParameters(scriptDescriptor: ScriptDescriptor): List { + return emptyList() } - public void addDelegateProvider(PackageMemberDeclarationProvider provider) { - delegateProvider = new CombinedPackageMemberDeclarationProvider(Lists.newArrayList(provider, delegateProvider)); - - setDelegate(delegateProvider); + override fun isScript(file: PsiFile): Boolean { + return StandardScriptDefinition.isScript(file) } + + override fun getScriptName(script: KtScript): Name { + return StandardScriptDefinition.getScriptName(script) + } + } + + private fun prepareForTheNextReplLine(c: TopDownAnalysisContext) { + c.scripts.clear() + } + + private fun renderStackTrace(cause: Throwable): String { + val oldTrace = cause.stackTrace + val newTrace = ArrayList() + var skip = true + for (i in oldTrace.indices.reversed()) { + val element = oldTrace[i] + // All our code happens in the script constructor, and no reflection/native code happens in constructors. + // So we ignore everything in the stack trace until the first constructor + if (element.getMethodName() == "") { + skip = false + } + if (!skip) { + newTrace.add(element) + } + } + Collections.reverse(newTrace) + + // throw away last element which contains Line1.kts(Unknown source) + val resultingTrace = newTrace.subList(0, newTrace.size - 1) + + @Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN") + (cause as java.lang.Throwable).setStackTrace(resultingTrace.toTypedArray()) + + return Throwables.getStackTraceAsString(cause) + } + + fun compileScript( + script: KtScript, + earlierScripts: List, + state: GenerationState, + errorHandler: CompilationErrorHandler) { + state.replSpecific.scriptResultFieldName = SCRIPT_RESULT_FIELD_NAME + state.replSpecific.earlierScriptsForReplInterpreter = ArrayList(earlierScripts) + + state.beforeCompile() + KotlinCodegenFacade.generatePackage( + state, + script.getContainingKtFile().packageFqName, + setOf(script.getContainingKtFile()), + errorHandler) } } }