From 49714d08170fb7b99c9a08ca3d956b425582e1b3 Mon Sep 17 00:00:00 2001 From: Dmitry Jemerov Date: Thu, 2 Jul 2015 17:50:22 +0200 Subject: [PATCH] convert KotlinRunConfigurationProducer to new API, allowing it to coexist with KotlinJUnitRunConfigurationProducer correctly #KT-2604 Fixed --- idea/src/META-INF/plugin.xml | 2 +- .../run/KotlinRunConfigurationProducer.kt | 107 ++++++++---------- 2 files changed, 46 insertions(+), 63 deletions(-) diff --git a/idea/src/META-INF/plugin.xml b/idea/src/META-INF/plugin.xml index f8090e618c0..75d442a17af 100644 --- a/idea/src/META-INF/plugin.xml +++ b/idea/src/META-INF/plugin.xml @@ -391,7 +391,7 @@ - + .clone() as KotlinRunConfigurationProducer +public class KotlinRunConfigurationProducer : RunConfigurationProducer(JetRunConfigurationType.getInstance()) { + + override fun setupConfigurationFromContext(configuration: JetRunConfiguration, + context: ConfigurationContext, + sourceElement: Ref): Boolean { + val location = context.getLocation() ?: return false + val module = context.getModule() ?: return false + val container = getEntryPointContainer(location) + val startClassFQName = getStartClassFqName(container) ?: return false + + setupConfigurationByQName(module, configuration, startClassFQName) + return true } - private var mySourceElement: PsiElement? = null - - override fun getSourceElement(): PsiElement? { - return mySourceElement - } - - override fun createConfigurationByElement(location: Location<*>, configurationContext: ConfigurationContext): RunnerAndConfigurationSettings? { - val container = getEntryPointContainer(location) ?: return null - - mySourceElement = container as PsiElement? - - val startClassFQName = getStartClassFqName(container) - if (startClassFQName == null) return null - - val module = location.getModule() - assert(module != null) - - return createConfigurationByQName(module, configurationContext, startClassFQName) - } - - private fun getStartClassFqName(container: JetDeclarationContainer?): FqName? { - if (container == null) return null - if (container is JetFile) return PackageClassUtils.getPackageClassFqName((container as JetFile?).getPackageFqName()) - if (container is JetClassOrObject) { + private fun getStartClassFqName(container: JetDeclarationContainer?): FqName? = when(container) { + null -> null + is JetFile -> PackageClassUtils.getPackageClassFqName(container.getPackageFqName()) + is JetClassOrObject -> { if (container is JetObjectDeclaration && container.isCompanion()) { - val containerClass = PsiTreeUtil.getParentOfType(container, javaClass()) - return containerClass?.getFqName() + val containerClass = container.getParentOfType(true) + containerClass?.getFqName() + } else { + container.getFqName() } - return container?.getFqName() } - throw IllegalArgumentException("Invalid entry-point container: " + (container as PsiElement?).getText()) + else -> throw IllegalArgumentException("Invalid entry-point container: " + (container as PsiElement).getText()) } - private fun getEntryPointContainer(location: Location<*>): JetDeclarationContainer? { + private fun getEntryPointContainer(location: Location<*>?): JetDeclarationContainer? { + if (location == null) return null if (DumbService.getInstance(location.getProject()).isDumb()) return null val module = location.getModule() ?: return null @@ -88,51 +81,41 @@ public class KotlinRunConfigurationProducer : RuntimeConfigurationProducer(JetRu if (!(psiFile is JetFile && ProjectRootsUtil.isInProjectOrLibSource(psiFile))) return null val resolutionFacade = psiFile.getResolutionFacade() - val mainFunctionDetector = MainFunctionDetector(object : NotNullFunction { - override fun `fun`(function: JetNamedFunction): FunctionDescriptor { - return resolutionFacade.resolveToDescriptor(function) as FunctionDescriptor - } - }) + val mainFunctionDetector = MainFunctionDetector { resolutionFacade.resolveToDescriptor(it) as FunctionDescriptor } - var currentElement = PsiTreeUtil.getNonStrictParentOfType(locationElement, javaClass(), javaClass()) as JetDeclarationContainer + var currentElement = locationElement.declarationContainer(false) while (currentElement != null) { var entryPointContainer = currentElement if (entryPointContainer is JetClass) { - entryPointContainer = entryPointContainer.getCompanionObjects().singleOrNull() as JetDeclarationContainer + entryPointContainer = entryPointContainer.getCompanionObjects().singleOrNull() } if (entryPointContainer != null && mainFunctionDetector.hasMain(entryPointContainer.getDeclarations())) return entryPointContainer - currentElement = PsiTreeUtil.getParentOfType(currentElement as PsiElement?, javaClass(), javaClass()) as JetDeclarationContainer + currentElement = (currentElement as PsiElement).declarationContainer(true) } return null } - private fun createConfigurationByQName(module: Module, context: ConfigurationContext, fqName: FqName): RunnerAndConfigurationSettings { - val settings = cloneTemplateConfiguration(module.getProject(), context) - val configuration = settings.getConfiguration() as JetRunConfiguration + private fun PsiElement.declarationContainer(strict: Boolean): JetDeclarationContainer? { + val element = if (strict) + PsiTreeUtil.getParentOfType(this, javaClass(), javaClass()) + else + PsiTreeUtil.getNonStrictParentOfType(this, javaClass(), javaClass()) + return element as JetDeclarationContainer? + } + + private fun setupConfigurationByQName(module: Module, + configuration: JetRunConfiguration, + fqName: FqName) { configuration.setModule(module) configuration.setName(StringUtil.trimEnd(fqName.asString(), "." + PackageClassUtils.getPackageClassName(fqName))) configuration.setRunClass(fqName.asString()) - return settings } - override fun findExistingByElement(location: Location<*>?, existingConfigurations: List, context: ConfigurationContext?): RunnerAndConfigurationSettings? { - val startClassFQName = getStartClassFqName(getEntryPointContainer(location)) ?: return null + override fun isConfigurationFromContext(configuration: JetRunConfiguration, context: ConfigurationContext): Boolean { + val startClassFQName = getStartClassFqName(getEntryPointContainer(context.getLocation())) ?: return false - for (existingConfiguration in existingConfigurations) { - if (existingConfiguration.getType() is JetRunConfigurationType) { - val jetConfiguration = existingConfiguration.getConfiguration() as JetRunConfiguration - if (Comparing.equal(jetConfiguration.getRunClass(), startClassFQName.asString())) { - if (Comparing.equal(location!!.getModule(), jetConfiguration.getConfigurationModule().getModule())) { - return existingConfiguration - } - } - } - } - return null - } - - override fun compareTo(o: Any?): Int { - return RuntimeConfigurationProducer.PREFERED + return configuration.getRunClass() == startClassFQName.asString() && + context.getModule() == configuration.getConfigurationModule().getModule() } }