Gradle: collect kotlin files from java source root

libraries/tools/kotlin-gradle-plugin-core/src/main/kotlin/org/jetbrains/kotlin/gradle/tasks/Tasks.kt

@@ -29,6 +29,7 @@ import org.jetbrains.kotlin.cli.common.CLICompiler
 import com.intellij.ide.highlighter.JavaFileType
 import org.jetbrains.kotlin.idea.JetFileType
 import org.jetbrains.kotlin.utils.LibraryUtils
+import com.intellij.openapi.util.io.FileUtil
 
 val DEFAULT_ANNOTATIONS = "org.jebrains.kotlin.gradle.defaultAnnotations"
 
@@ -121,7 +122,7 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
         args.noParamAssertions = kotlinOptions.noParamAssertions
     }
 
-    private fun getJavaSourceRoots(): Set<File> = 
+    private fun getJavaSourceRoots(): Set<File> =
             getSource()
             .filter { isJava(it) }
             .map { findSrcDirRoot(it) }
@@ -160,7 +161,7 @@ public open class KotlinCompile() : AbstractKotlinCompile<K2JVMCompilerArguments
     fun findSrcDirRoot(file: File): File? {
         for (source in srcDirsSources) {
             for (root in source.getSrcDirs()) {
-                if (FileUtils.directoryContains(root, file)) {
+                if (FileUtil.isAncestor(root, file, false)) {
                     return root
                 }
             }

libraries/tools/kotlin-gradle-plugin/src/main/kotlin/org/jetbrains/kotlin/gradle/plugin/KotlinPlugin.kt

@@ -134,6 +134,14 @@ class Kotlin2JvmSourceSetProcessor(
             val javacClassPath = javaTask.getClasspath() + project.files(kotlinDestinationDir);
             javaTask.setClasspath(javacClassPath)
         }
+
+        project afterEvaluate { project ->
+            if (project != null) {
+                for (dir in sourceSet.getJava().getSrcDirs()) {
+                    kotlinDirSet?.srcDir(dir)
+                }
+            }
+        }
     }
 }
 
@@ -332,19 +340,25 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler, val t
 
                 val javaSourceList = ArrayList<Any?>()
 
+                fun processSourceSet(javaSourceSet: AndroidSourceSet) {
+                    val javaSrcDirs = AndroidGradleWrapper.getJavaSrcDirs(javaSourceSet)
+                    javaSourceList.addAll(javaSrcDirs)
+                    val testKotlinSource = getExtension<KotlinSourceSet>(javaSourceSet, "kotlin")
+                    val kotlinSDS = testKotlinSource.getKotlin()
+                    for (dir in javaSrcDirs) {
+                        kotlinSDS.srcDir(dir)
+                    }
+                    kotlinTask.source(kotlinSDS)
+                }
+
                 if (variant is TestVariant) {
-                    javaSourceList.addAll(AndroidGradleWrapper.getJavaSrcDirs(testSourceSet))
-                    val testKotlinSource = getExtension<KotlinSourceSet>(testSourceSet, "kotlin")
-                    kotlinTask.source(testKotlinSource.getKotlin())
+                    processSourceSet(testSourceSet)
                 } else {
-                    javaSourceList.addAll(AndroidGradleWrapper.getJavaSrcDirs(mainSourceSet))
-                    val mainKotlinSource = getExtension<KotlinSourceSet>(mainSourceSet, "kotlin")
-                    kotlinTask.source(mainKotlinSource.getKotlin())
+                    processSourceSet(mainSourceSet)
                 }
 
                 if (null != buildTypeSourceSet) {
-                    javaSourceList.add(AndroidGradleWrapper.getJavaSrcDirs(buildTypeSourceSet))
-                    kotlinTask.source(getExtension<KotlinSourceSet>(buildTypeSourceSet, "kotlin").getKotlin())
+                    processSourceSet(buildTypeSourceSet)
                 }
 
                 for (resourceFolder in AndroidGradleWrapper.getRClassFolder(variant)) {
@@ -359,14 +373,12 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler, val t
                         val defaultFlavourSourceSetName = flavourName + buildTypeSourceSetName.capitalize()
                         val defaultFlavourSourceSet = sourceSets.findByName(defaultFlavourSourceSetName)
                         if (defaultFlavourSourceSet != null) {
-                            javaSourceList.add(AndroidGradleWrapper.getJavaSrcDirs(defaultFlavourSourceSet))
-                            kotlinTask.source(getExtension<KotlinSourceSet>(defaultFlavourSourceSet, "kotlin").getKotlin())
+                            processSourceSet(defaultFlavourSourceSet)
                         }
 
                         val flavourSourceSet = sourceSets.findByName(flavourName)
                         if (flavourSourceSet != null) {
-                            javaSourceList.add(AndroidGradleWrapper.getJavaSrcDirs(flavourSourceSet))
-                            kotlinTask.source(getExtension<KotlinSourceSet>(flavourSourceSet, "kotlin").getKotlin())
+                            processSourceSet(flavourSourceSet)
                         }
                     }
                 }
@@ -403,7 +415,7 @@ open class KotlinAndroidPlugin [Inject] (val scriptHandler: ScriptHandler, val t
 
 }
 
-    
+
 open class GradleUtils(val scriptHandler: ScriptHandler, val project: ProjectInternal) {
     public fun resolveDependencies(vararg coordinates: String): Collection<File> {
         val dependencyHandler: DependencyHandler = scriptHandler.getDependencies()

libraries/tools/kotlin-gradle-plugin/src/test/kotlin/org/jetbrains/kotlin/gradle/KotlinGradlePluginIT.kt

@@ -50,4 +50,12 @@ class KotlinGradleIT: BaseGradleIT() {
             assertContains(":subproject:compileKotlin", ":subproject:compileTestKotlin")
         }
     }
+
+    Test fun testKotlinInJavaRoot() {
+        Project("kotlinInJavaRoot", "1.6").build("build") {
+            assertSuccessful()
+            assertReportExists()
+            assertContains(":compileKotlin", ":compileTestKotlin")
+        }
+    }
 }

libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kotlinInJavaRoot/build.gradle

@@ -0,0 +1,43 @@
+buildscript {
+  repositories {
+    mavenCentral()
+    maven {
+        url 'file://' + pathToKotlinPlugin
+    }
+  }
+  dependencies {
+    classpath 'org.jetbrains.kotlin:kotlin-gradle-plugin:0.1-SNAPSHOT'
+  }
+}
+
+apply plugin: "kotlin"
+apply plugin: 'java'
+
+repositories {
+  maven {
+     url 'file://' + pathToKotlinPlugin
+  }
+  mavenCentral()
+}
+
+sourceSets {
+    main.java.srcDirs += 'src/main/java2'
+}
+
+dependencies {
+    compile 'com.google.guava:guava:12.0'
+    testCompile  'org.testng:testng:6.8'
+    testRuntime  'org.jetbrains.kotlin:kotlin-stdlib:0.1-SNAPSHOT'
+}
+
+test {
+    useTestNG()
+}
+
+task show << {
+   buildscript.configurations.classpath.each { println it }
+}
+
+task wrapper(type: Wrapper) {
+  gradleVersion="1.6"
+}

libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kotlinInJavaRoot/src/main/java/javaPackage/JavaClass.java

@@ -0,0 +1,15 @@
+package javaPackage;
+
+import kotlinPackage.*;
+import kotlinPackage2.*;
+
+public class JavaClass {
+    public void foo() {
+
+    }
+
+    public static void main(String[] args) {
+        new KotlinClass().foo();
+        new KotlinClass2().foo();
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kotlinInJavaRoot/src/main/java/kotlinPackage/KotlinClass.kt

@@ -0,0 +1,14 @@
+package kotlinPackage
+
+import javaPackage.*
+import javaPackage2.*
+
+public class KotlinClass() {
+    fun foo() {}
+}
+
+fun main() {
+    JavaClass().foo()
+    JavaClass2().foo()
+}
+

libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kotlinInJavaRoot/src/main/java2/javaPackage2/JavaClass2.java

@@ -0,0 +1,15 @@
+package javaPackage2;
+
+import kotlinPackage.*;
+import kotlinPackage2.*;
+
+public class JavaClass2 {
+    public void foo() {
+
+    }
+
+    public static void main(String[] args) {
+        new KotlinClass().foo();
+        new KotlinClass2().foo();
+    }
+}

libraries/tools/kotlin-gradle-plugin/src/test/resources/testProject/kotlinInJavaRoot/src/main/java2/kotlinPackage2/KotlinClass2.kt

@@ -0,0 +1,14 @@
+package kotlinPackage2
+
+import javaPackage.*
+import javaPackage2.*
+
+public class KotlinClass2() {
+    fun foo() {}
+}
+
+fun main() {
+    JavaClass().foo()
+    JavaClass2().foo()
+}
+