Change KotlinProjectConfigurator API to return module status as a single enum instead of two distinct boolean values

idea/idea-maven/src/org/jetbrains/kotlin/idea/maven/configuration/KotlinMavenConfigurator.kt

@@ -33,6 +33,7 @@ import com.intellij.psi.xml.XmlFile
 import org.jetbrains.idea.maven.dom.MavenDomUtil
 import org.jetbrains.idea.maven.dom.model.MavenDomPlugin
 import org.jetbrains.idea.maven.model.MavenId
+import org.jetbrains.idea.maven.project.MavenProject
 import org.jetbrains.idea.maven.project.MavenProjectsManager
 import org.jetbrains.idea.maven.utils.MavenArtifactScope
 import org.jetbrains.kotlin.idea.KotlinPluginUtil
@@ -48,14 +49,9 @@ abstract class KotlinMavenConfigurator
                               override val name: String,
                               override val presentableText: String) : KotlinProjectConfigurator {
 
-    override fun isApplicable(module: Module): Boolean {
+    override fun getStatus(module: Module): ConfigureKotlinStatus {
-        return KotlinPluginUtil.isMavenModule(module)
+        if (!KotlinPluginUtil.isMavenModule(module))
-    }
+            return ConfigureKotlinStatus.NON_APPLICABLE
-
-    override fun isConfigured(module: Module): Boolean {
-        if (!isKotlinModule(module)) {
-            return false
-        }
 
         val psi = findModulePomFile(module)
         if (psi == null
@@ -63,11 +59,18 @@ abstract class KotlinMavenConfigurator
             || psi !is XmlFile
             || psi.virtualFile == null
             || MavenDomUtil.getMavenDomProjectModel(module.project, psi.virtualFile) == null) {
-            return false
+            return ConfigureKotlinStatus.BROKEN
         }
 
-        val mavenProject = MavenProjectsManager.getInstance(module.project).findProject(module) ?: return false
+        val mavenProject = MavenProjectsManager.getInstance(module.project).findProject(module) ?: return ConfigureKotlinStatus.BROKEN
 
+        if (isKotlinModule(module) && hasKotlinPlugin(mavenProject)) {
+            return ConfigureKotlinStatus.CONFIGURED
+        }
+        return ConfigureKotlinStatus.CAN_BE_CONFIGURED
+    }
+
+    private fun hasKotlinPlugin(mavenProject: MavenProject): Boolean {
         val plugin = mavenProject.findPlugin(GROUP_ID, MAVEN_PLUGIN_ID) ?: return false
 
         return plugin.executions?.any { it.goals?.any { it != null && isRelevantGoal(it) } ?: false } ?: false

idea/src/org/jetbrains/kotlin/idea/configuration/ConfigureKotlinInProjectUtils.kt

@@ -47,14 +47,10 @@ val EAP_REPOSITORY = RepositoryDescription(
         "http://dl.bintray.com/kotlin/kotlin-eap",
         isSnapshot = false)
 
-fun isProjectConfigured(project: Project): Boolean {
-    val modules = getModulesWithKotlinFiles(project)
-    return modules.all { isModuleConfigured(it) }
-}
-
 fun isModuleConfigured(module: Module): Boolean {
-    val configurators = getApplicableConfigurators(module)
+    return Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME).any {
-    return configurators.any { it.isConfigured(module) }
+        it.getStatus(module) == ConfigureKotlinStatus.CONFIGURED
+    }
 }
 
 fun getModulesWithKotlinFiles(project: Project): Collection<Module> {
@@ -95,12 +91,12 @@ fun getAbleToRunConfigurators(project: Project): Collection<KotlinProjectConfigu
     val modules = getModulesWithKotlinFiles(project).ifEmpty { project.allModules() }
 
     return Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME).filter { configurator ->
-        modules.any { module -> configurator.isApplicable(module) && !configurator.isConfigured(module) }
+        modules.any { module -> configurator.getStatus(module) == ConfigureKotlinStatus.CAN_BE_CONFIGURED }
     }
 }
 
-fun getApplicableConfigurators(module: Module): Collection<KotlinProjectConfigurator> {
+fun getAbleToRunConfigurators(module: Module): Collection<KotlinProjectConfigurator> {
-    return Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME).filter { it.isApplicable(module) }
+    return Extensions.getExtensions(KotlinProjectConfigurator.EP_NAME).filter { it.getStatus(module) == ConfigureKotlinStatus.CAN_BE_CONFIGURED }
 }
 
 fun getConfiguratorByName(name: String): KotlinProjectConfigurator? {
@@ -108,19 +104,19 @@ fun getConfiguratorByName(name: String): KotlinProjectConfigurator? {
 }
 
 fun getNonConfiguredModules(project: Project, configurator: KotlinProjectConfigurator): List<Module> {
-    return project.allModules().filter { module -> configurator.isApplicable(module) && !configurator.isConfigured(module) }
+    return project.allModules().filter { module -> configurator.getStatus(module) == ConfigureKotlinStatus.CAN_BE_CONFIGURED }
 }
 
 fun getNonConfiguredModulesWithKotlinFiles(project: Project, configurator: KotlinProjectConfigurator): List<Module> {
     val modules = getModulesWithKotlinFiles(project)
-    return modules.filter { module -> configurator.isApplicable(module) && !configurator.isConfigured(module) }
+    return modules.filter { module -> configurator.getStatus(module) == ConfigureKotlinStatus.CAN_BE_CONFIGURED }
 }
 
 fun getNonConfiguredModules(project: Project, excludeModules: Collection<Module> = emptyList()): Collection<Module> {
     val modulesWithKotlinFiles = getModulesWithKotlinFiles(project) - excludeModules
     val ableToRunConfigurators = getAbleToRunConfigurators(project)
     return modulesWithKotlinFiles.filter { module ->
-        ableToRunConfigurators.any { !it.isConfigured(module) }
+        ableToRunConfigurators.any { it.getStatus(module) == ConfigureKotlinStatus.CAN_BE_CONFIGURED }
     }
 }
 

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinProjectConfigurator.kt

@@ -21,11 +21,23 @@ import com.intellij.openapi.module.Module
 import com.intellij.openapi.project.Project
 import org.jetbrains.kotlin.resolve.TargetPlatform
 
+enum class ConfigureKotlinStatus {
+    /** Kotlin is correctly configured using this configurator. */
+    CONFIGURED,
+    /** The configurator is not applicable to the current project type. */
+    NON_APPLICABLE,
+    /** The configurator is applicable to the current project type and can configure Kotlin automatically. */
+    CAN_BE_CONFIGURED,
+    /**
+     * The configurator is applicable to the current project type and Kotlin is not configured,
+     * but the state of the project doesn't allow to configure Kotlin automatically.
+     */
+    BROKEN
+}
+
 interface KotlinProjectConfigurator {
 
-    fun isConfigured(module: Module): Boolean
+    fun getStatus(module: Module): ConfigureKotlinStatus
-
-    fun isApplicable(module: Module): Boolean
 
     @JvmSuppressWildcards fun configure(project: Project, excludeModules: Collection<Module>)
 

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinSetupEnvironmentNotificationProvider.kt

@@ -107,7 +107,7 @@ class KotlinSetupEnvironmentNotificationProvider(
         private fun createKotlinNotConfiguredPanel(module: Module): EditorNotificationPanel {
             return EditorNotificationPanel().apply {
                 setText("Kotlin not configured")
-                val configurators = getApplicableConfigurators(module).toList()
+                val configurators = getAbleToRunConfigurators(module).toList()
                 if (!configurators.isEmpty()) {
                     createComponentActionLabel("Configure") { label ->
                         val configuratorsPopup = createConfiguratorsPopup(module.project, configurators)
@@ -125,9 +125,7 @@ class KotlinSetupEnvironmentNotificationProvider(
 
                 override fun onChosen(selectedValue: KotlinProjectConfigurator?, finalChoice: Boolean): PopupStep<*>? {
                     return doFinalStep {
-                        selectedValue?.let {
+                        selectedValue?.configure(project, emptyList())
-                            it.configure(project, emptyList())
-                        }
                     }
                 }
             }

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinWithGradleConfigurator.java

@@ -71,20 +71,32 @@ public abstract class KotlinWithGradleConfigurator implements KotlinProjectConfi
     protected static final String SOURCE_SET = "main.java.srcDirs += 'src/main/kotlin'\n";
     private static final String VERSION = String.format("ext.kotlin_version = '%s'", VERSION_TEMPLATE);
 
+    @NotNull
     @Override
-    public boolean isConfigured(@NotNull Module module) {
+    public ConfigureKotlinStatus getStatus(@NotNull Module module) {
+        if (!isApplicable(module)) {
+            return ConfigureKotlinStatus.NON_APPLICABLE;
+        }
+
         if (ConfigureKotlinInProjectUtilsKt.hasKotlinJvmRuntimeInScope(module)) {
-            return true;
+            return ConfigureKotlinStatus.CONFIGURED;
         }
 
         GroovyFile moduleGradleFile = getBuildGradleFile(module.getProject(), getModuleFilePath(module));
-        if (moduleGradleFile != null && isFileConfigured(moduleGradleFile)) {
+        if (moduleGradleFile != null && !isFileConfigured(moduleGradleFile)) {
-            return true;
+            return ConfigureKotlinStatus.CAN_BE_CONFIGURED;
         }
+
         GroovyFile projectGradleFile = getBuildGradleFile(module.getProject(), getTopLevelProjectFilePath(module.getProject()));
-        return projectGradleFile != null && isFileConfigured(projectGradleFile);
+        if (projectGradleFile != null && !isFileConfigured(projectGradleFile)) {
+            return ConfigureKotlinStatus.CAN_BE_CONFIGURED;
+        }
+
+        return ConfigureKotlinStatus.BROKEN;
     }
 
+    protected abstract boolean isApplicable(@NotNull Module module);
+
     private boolean isFileConfigured(GroovyFile projectGradleFile) {
         String fileText = projectGradleFile.getText();
         return containsDirective(fileText, getApplyPluginDirective()) && fileText.contains(LIBRARY);

idea/src/org/jetbrains/kotlin/idea/configuration/KotlinWithLibraryConfigurator.java

@@ -38,7 +38,6 @@ import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.idea.KotlinPluginUtil;
 import org.jetbrains.kotlin.idea.framework.ui.CreateLibraryDialogWithModules;
 import org.jetbrains.kotlin.idea.framework.ui.FileUIUtils;
-import org.jetbrains.kotlin.idea.project.ProjectStructureUtil;
 
 import java.io.File;
 import java.util.Arrays;
@@ -66,13 +65,26 @@ public abstract class KotlinWithLibraryConfigurator implements KotlinProjectConf
     @Nullable
     protected abstract String getOldSourceRootUrl(@NotNull Library library);
 
+    @NotNull
     @Override
-    public boolean isApplicable(@NotNull Module module) {
+    public ConfigureKotlinStatus getStatus(@NotNull Module module) {
+        if (!isApplicable(module)) {
+            return ConfigureKotlinStatus.NON_APPLICABLE;
+        }
+        if (isConfigured(module)) {
+            return ConfigureKotlinStatus.CONFIGURED;
+        }
+        return ConfigureKotlinStatus.CAN_BE_CONFIGURED;
+    }
+
+    protected static boolean isApplicable(@NotNull Module module) {
         return !KotlinPluginUtil.isAndroidGradleModule(module) &&
                !KotlinPluginUtil.isMavenModule(module) &&
                !KotlinPluginUtil.isGradleModule(module);
     }
 
+    protected abstract boolean isConfigured(@NotNull Module module);
+
     @Override
     public void configure(@NotNull Project project, Collection<Module> excludeModules) {
         String defaultPathToJar = getDefaultPathToJarFile(project);