Cache module type

idea/src/META-INF/plugin.xml

@@ -113,6 +113,9 @@
     <projectService serviceInterface="org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider"
                     serviceImplementation="org.jetbrains.jet.lang.parsing.JetScriptDefinitionProvider"/>
 
+    <projectService serviceInterface="org.jetbrains.jet.plugin.configuration.ModuleTypeCacheManager"
+                    serviceImplementation="org.jetbrains.jet.plugin.configuration.ModuleTypeCacheManager"/>
+
     <errorHandler implementation="org.jetbrains.jet.plugin.reporter.KotlinReportSubmitter"/>
 
     <internalFileTemplate name="Kotlin File"/>

idea/src/org/jetbrains/jet/plugin/JetPluginUtil.java

@@ -40,6 +40,7 @@ import org.jetbrains.jet.lang.types.DeferredType;
 import org.jetbrains.jet.lang.types.ErrorUtils;
 import org.jetbrains.jet.lang.types.JetType;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
+import org.jetbrains.jet.plugin.configuration.ModuleTypeCacheManager;
 
 import java.util.LinkedList;
 
@@ -150,11 +151,7 @@ public class JetPluginUtil {
     }
 
     public static boolean isGradleModule(@NotNull Module module) {
-        VirtualFile moduleFile = module.getModuleFile();
+        return ModuleTypeCacheManager.object$.geInstance(module.getProject()).isGradleModule(module);
-        if (moduleFile == null) return false;
-
-        VirtualFile buildFile = moduleFile.getParent().findChild("build.gradle");
-        return buildFile != null && buildFile.exists();
     }
 
     public static boolean isMavenModule(@NotNull Module module) {

idea/src/org/jetbrains/jet/plugin/configuration/ModuleTypeCache.kt

@@ -0,0 +1,88 @@
+package org.jetbrains.jet.plugin.configuration
+
+import com.intellij.openapi.module.Module
+import com.intellij.openapi.components.ServiceManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.psi.util.CachedValueProvider
+import com.intellij.psi.util.CachedValuesManager
+import com.intellij.openapi.util.DefaultModificationTracker
+import com.intellij.openapi.vfs.impl.BulkVirtualFileListenerAdapter
+import com.intellij.openapi.vfs.VirtualFileAdapter
+import com.intellij.openapi.vfs.VirtualFileEvent
+import com.intellij.openapi.vfs.VirtualFileMoveEvent
+import com.intellij.openapi.vfs.VirtualFileCopyEvent
+import com.intellij.openapi.vfs.VirtualFilePropertyEvent
+
+class ModuleTypeCacheManager private (project: Project) {
+    class object {
+        fun geInstance(project: Project) = ServiceManager.getService(project, javaClass<ModuleTypeCacheManager>())
+    }
+
+    private val vfsModificationTracker = VfsModificationTracker(project)
+
+    private val cachedValue = CachedValuesManager.getManager(project).createParameterizedCachedValue(
+            {
+                (module: Module?) ->
+                val moduleType = if (module != null) computeType(module) else null
+                CachedValueProvider.Result.create<ModuleType>(moduleType, vfsModificationTracker)
+            }, false)
+
+    fun isGradleModule(module: Module) = getModuleType(module) == ModuleType.GRADLE
+
+    private fun getModuleType(module: Module): ModuleType? {
+        return cachedValue?.getValue(module)
+    }
+
+    private class VfsModificationTracker(project: Project): DefaultModificationTracker() {
+        {
+            val connection = project.getMessageBus().connect();
+            connection.subscribe(VirtualFileManager.VFS_CHANGES, BulkVirtualFileListenerAdapter(
+                    object : VirtualFileAdapter() {
+                        override fun propertyChanged(event: VirtualFilePropertyEvent?) {
+                            incModificationCount()
+                        }
+
+                        override fun fileCreated(event: VirtualFileEvent?) {
+                            incModificationCount()
+                        }
+
+                        override fun fileDeleted(event: VirtualFileEvent?) {
+                            incModificationCount()
+                        }
+
+                        override fun fileMoved(event: VirtualFileMoveEvent?) {
+                            incModificationCount()
+                        }
+
+                        override fun fileCopied(event: VirtualFileCopyEvent?) {
+                            incModificationCount()
+                        }
+                    }
+            ))
+        }
+    }
+}
+
+enum class ModuleType {
+    GRADLE
+    OTHER
+}
+
+private fun computeType(module: Module) =
+        when {
+            isGradleModule(module) -> ModuleType.GRADLE
+            else -> ModuleType.OTHER
+        }
+
+private val DEFAULT_SCRIPT_NAME = "build.gradle"
+
+private fun isGradleModule(module: Module): Boolean {
+    val moduleFile = module.getModuleFile()
+    if (moduleFile == null){
+        return false
+    }
+
+    val buildFile = moduleFile.getParent()?.findChild(DEFAULT_SCRIPT_NAME)
+    return buildFile != null && buildFile.exists()
+}