Adds support for gradle projects with multiple modules

Author: Kordyjan

kotlin-eclipse-core/src/org/jetbrains/kotlin/core/filesystem/KotlinLightClassManager.java

@@ -16,10 +16,13 @@
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
 import org.eclipse.core.resources.IProject;
-import org.eclipse.core.resources.IResource;
 import org.eclipse.core.resources.ResourcesPlugin;
 import org.eclipse.core.resources.WorkspaceJob;
-import org.eclipse.core.runtime.*;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IPath;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Path;
 import org.eclipse.jdt.internal.core.util.LRUCache;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -44,8 +47,6 @@
 import com.intellij.psi.PsiElement;
 import com.intellij.psi.util.PsiTreeUtil;
 
-import kotlin.jvm.functions.Function1;
-
 public class KotlinLightClassManager {
     private static final int LIGHT_CLASSES_CACHE_SIZE = 300;
 
@@ -112,8 +113,7 @@ public void updateLightClasses(@NotNull Set<IFile> affectedFiles, Boolean resour
             if (lightClassIFile == null) continue;
 
             LightClassFile lightClassFile = new LightClassFile(lightClassIFile);
-            
-            createParentDirsFor(lightClassFile);
+
             if (!lightClassFile.exists()) {
                 toCreate.add(lightClassFile);
             }
@@ -147,6 +147,7 @@ public IStatus runInWorkspace(IProgressMonitor monitor) {
 
     private void updateLightClasses(List<LightClassFile> toCreate, List<LightClassFile> toRemove) {
         for (LightClassFile lightClassFile: toCreate) {
+            createParentDirsFor(lightClassFile);
             lightClassFile.createIfNotExists();
         }
         for (LightClassFile lightClassFile: toRemove) {

kotlin-eclipse-gradle-model/src/org/jetbrains/kotlin/gradle/model/GradleMultiProjectForEclipse.kt

@@ -0,0 +1,13 @@
+package org.jetbrains.kotlin.gradle.model
+
+import java.io.Serializable
+
+interface GradleMultiProjectForEclipse : Serializable {
+    operator fun get(name: String): GradleProjectForEclipse?
+}
+
+class GradleMultiProjectForEclipseImpl(
+    private val subprojects: Map<String, GradleProjectForEclipse>
+) : GradleMultiProjectForEclipse {
+    override fun get(name: String) = subprojects[name]
+}

kotlin-eclipse-gradle/scripts/init.gradle.kts

@@ -5,6 +5,8 @@ import org.gradle.tooling.provider.model.ToolingModelBuilder
 import org.gradle.tooling.provider.model.ToolingModelBuilderRegistry
 import org.jetbrains.kotlin.gradle.model.GradleProjectForEclipse
 import org.jetbrains.kotlin.gradle.model.GradleProjectForEclipseImpl
+import org.jetbrains.kotlin.gradle.model.GradleMultiProjectForEclipse
+import org.jetbrains.kotlin.gradle.model.GradleMultiProjectForEclipseImpl
 import org.jetbrains.kotlin.gradle.model.NoKotlinProject
 import org.jetbrains.kotlin.gradle.model.CompilerPluginConfig
 import org.jetbrains.kotlin.gradle.model.AllOpen
@@ -27,28 +29,36 @@ allprojects {
     apply<GradleProjectForEclipseInstaller>()
 }
 
-class GradleProjectForEclipseInstaller @Inject constructor(val registry: ToolingModelBuilderRegistry) : Plugin<Project> {
+class GradleProjectForEclipseInstaller @Inject constructor(val registry: ToolingModelBuilderRegistry) :
+    Plugin<Project> {
     override fun apply(project: Project) {
         registry.register(GradleProjectForEclipseBuilder())
     }
 }
 
 class GradleProjectForEclipseBuilder() : ToolingModelBuilder {
-    override fun canBuild(modelName: String) = (modelName == GradleProjectForEclipse::class.qualifiedName)
-
-    override fun buildAll(modelName: String, project: Project): Any {
-        val task = project.tasks.findByName("compileKotlin")
-
-        return task?.dynamicCall("kotlinOptions")?.run {
-            GradleProjectForEclipseImpl(
-                project.findProperty("kotlin.code.style") as? String,
-                property("apiVersion"),
-                property("languageVersion"),
-                property("jvmTarget"),
-                collectPlugins(project)
-            )
-        } ?: return NoKotlinProject
-    }
+
+    override fun canBuild(modelName: String) = (modelName == GradleMultiProjectForEclipse::class.qualifiedName)
+
+    override fun buildAll(modelName: String, project: Project): Any =
+        GradleMultiProjectForEclipseImpl(process(project).toMap())
+
+    private fun process(project: Project): List<Pair<String, GradleProjectForEclipse>> =
+        project.childProjects.values.flatMap(::process) +
+                (project.name to buildForSubproject(project))
+
+    private fun buildForSubproject(project: Project): GradleProjectForEclipse =
+        project.tasks.findByName("compileKotlin")
+            ?.dynamicCall("kotlinOptions")
+            ?.run {
+                GradleProjectForEclipseImpl(
+                    project.findProperty("kotlin.code.style") as? String,
+                    property("apiVersion"),
+                    property("languageVersion"),
+                    property("jvmTarget"),
+                    collectPlugins(project)
+                )
+            } ?: NoKotlinProject
 
     private fun collectPlugins(project: Project): List<CompilerPluginConfig> {
         val result = arrayListOf<CompilerPluginConfig>()
@@ -74,16 +84,16 @@ class GradleProjectForEclipseBuilder() : ToolingModelBuilder {
                 it.dynamicCall("myPresets") as List<String>
             )
         }?.also { result += it }
-        
+
         return result
     }
-    
+
     // We need this method, because there is no way for us to get here classes that are added to classpath alongside
-    // the kotlin gradle plugin. Even if we add them to the classpath of this initscript, they will have different
-    // classloader.
+// the kotlin gradle plugin. Even if we add them to the classpath of this initscript, they will have different
+// classloader.
     fun Any.dynamicCall(name: String, vararg args: Any?): Any? =
         this::class.members.first { it.name == name && it.parameters.size == args.size + 1 }
-                .call(this, *args)
-    
+            .call(this, *args)
+
     fun Any.property(name: String): String? = dynamicCall(name) as? String
 }

kotlin-eclipse-gradle/src/org/jetbrains/kotlin/gradle/configurator/KotlinProjectConfigurator.kt

@@ -16,21 +16,29 @@ import org.jetbrains.kotlin.core.preferences.KotlinProperties
 import org.jetbrains.kotlin.core.utils.ProjectUtils
 import org.jetbrains.kotlin.gradle.model.GradleProjectForEclipse
 import org.jetbrains.kotlin.core.log.KotlinLogger
+import org.jetbrains.kotlin.gradle.model.GradleMultiProjectForEclipse
 
 class KotlinProjectConfigurator : ProjectConfigurator {
 
-    lateinit var model: GradleProjectForEclipse
+    lateinit var multiModel: GradleMultiProjectForEclipse
 
     override fun init(context: InitializationContext, monitor: IProgressMonitor) {
         context.gradleBuild.withConnection({
-            model = it.getModel(GradleProjectForEclipse::class.java)
+            multiModel = it.getModel(GradleMultiProjectForEclipse::class.java)
         }, monitor)
     }
 
     override fun configure(context: ProjectContext, monitor: IProgressMonitor) {
-        if (!::model.isInitialized || !model.isKotlinProject) return
-
         val project = context.project
+        
+        if (!::multiModel.isInitialized) return
+        val model = multiModel[project.name]
+        if (model == null || !model.isKotlinProject) {
+            // Kotlin nature may left in .project file after editing out kotlin plugin from gradle buildfile.
+            // This leads to nasty bugs so we have to unconfigure project.
+            unconfigure(context, monitor)
+            return
+        }
 
         KotlinNature.addNature(project)
         if (!ProjectUtils.hasKotlinRuntime(project)) {