diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
index 1609e9d466a..d85d97f2170 100644
--- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
+++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/caches/resolve/KotlinCacheService.kt
@@ -26,16 +26,15 @@ import com.intellij.psi.util.PsiModificationTracker
 import com.intellij.psi.util.CachedValueProvider
 import org.jetbrains.jet.lang.resolve.BindingContext
 import com.intellij.openapi.components.ServiceManager
-import com.intellij.psi.search.GlobalSearchScope
 import org.jetbrains.jet.plugin.project.AnalyzerFacadeProvider
 import org.jetbrains.jet.plugin.project.TargetPlatform
 import org.jetbrains.jet.plugin.project.TargetPlatform.*
 import org.jetbrains.jet.plugin.project.ResolveSessionForBodies
 import org.jetbrains.jet.plugin.project.TargetPlatformDetector
 import org.jetbrains.jet.lang.psi.JetCodeFragment
-import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
 import org.jetbrains.jet.utils.keysToMap
 import com.intellij.openapi.roots.ProjectRootModificationTracker
+import org.jetbrains.jet.plugin.util.ProjectRootsUtil
 
 private val LOG = Logger.getInstance(javaClass<KotlinCacheService>())
 
@@ -171,7 +170,7 @@ public class KotlinCacheService(val project: Project) {
 
     public fun getLazyResolveSession(element: JetElement): ResolveSessionForBodies {
         val file = element.getContainingJetFile()
-        if (!isFileInScope(file)) {
+        if (!ProjectRootsUtil.isInProjectSource(file)) {
             return getCacheForSyntheticFile(file).getLazyResolveSession(file)
         }
 
@@ -182,25 +181,13 @@ public class KotlinCacheService(val project: Project) {
         if (elements.isEmpty()) return AnalyzeExhaust.EMPTY
 
         val firstFile = elements.first().getContainingJetFile()
-        if (elements.size == 1 && (!isFileInScope(firstFile) && firstFile !is JetCodeFragment)) {
+        if (elements.size == 1 && (!ProjectRootsUtil.isInProjectSource(firstFile) && firstFile !is JetCodeFragment)) {
             return getCacheForSyntheticFile(firstFile).getAnalysisResultsForElements(elements)
         }
 
         return getGlobalCache(TargetPlatformDetector.getPlatform(firstFile)).getAnalysisResultsForElements(elements)
     }
 
-    private fun isFileInScope(jetFile: JetFile): Boolean {
-        val virtualFile = jetFile.getVirtualFile()
-        if (virtualFile == null) {
-            return false
-        }
-        return virtualFile in kotlinSourcesInProjectScope()
-    }
-
-    private fun kotlinSourcesInProjectScope(): GlobalSearchScope {
-        return JetSourceFilterScope.kotlinSources(GlobalSearchScope.allScope(project), project)
-    }
-
     public fun <T> get(extension: CacheExtension<T>): T {
         return getGlobalCache(extension.platform)[extension]
     }
diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java b/idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java
index bbc8cea70be..1682d54dbc4 100644
--- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java
+++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/stubindex/JetSourceFilterScope.java
@@ -23,7 +23,7 @@ import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.search.DelegatingGlobalSearchScope;
 import com.intellij.psi.search.GlobalSearchScope;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.plugin.configuration.JetModuleTypeManager;
+import org.jetbrains.jet.plugin.util.ProjectRootsUtil;
 
 public class JetSourceFilterScope extends DelegatingGlobalSearchScope {
     @NotNull
@@ -59,22 +59,6 @@ public class JetSourceFilterScope extends DelegatingGlobalSearchScope {
             return false;
         }
 
-        return isInProjectSources(project, file, index, /* withClassesRoots */ true, includeLibraries);
-    }
-
-    public static boolean isInProjectSources(
-            @NotNull Project project,
-            @NotNull VirtualFile file,
-            @NotNull ProjectFileIndex fileIndex,
-            boolean withClassesRoots,
-            boolean withLibraries
-    ) {
-        if (fileIndex.isInSourceContent(file)) {
-            return !JetModuleTypeManager.getInstance().isKtFileInGradleProjectInWrongFolder(file, project);
-        }
-
-        if (!withLibraries) return false;
-
-        return (withClassesRoots && fileIndex.isInLibraryClasses(file)) || fileIndex.isInLibrarySource(file);
+        return ProjectRootsUtil.isInSources(project, file, includeLibraries, /* withLibraryClassesRoots */ true, index);
     }
 }
diff --git a/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/ProjectRootsUtil.kt b/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/ProjectRootsUtil.kt
index b506f029f41..681fb850d2b 100644
--- a/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/ProjectRootsUtil.kt
+++ b/idea/idea-analysis/src/org/jetbrains/jet/plugin/util/ProjectRootsUtil.kt
@@ -21,9 +21,26 @@ import com.intellij.psi.PsiElement
 import kotlin.platform.platformStatic
 import org.jetbrains.jet.plugin.util.application.runReadAction
 import org.jetbrains.jet.plugin.stubindex.JetSourceFilterScope
+import org.jetbrains.jet.plugin.configuration.JetModuleTypeManager
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
 
 public object ProjectRootsUtil {
-    private fun isInSource(element: PsiElement, includeLibrarySources: Boolean): Boolean {
+    platformStatic
+    public fun isInSources(project: Project, file: VirtualFile,
+                           includeLibrarySources: Boolean, withLibraryClassesRoots: Boolean,
+                           fileIndex: ProjectFileIndex = ProjectFileIndex.SERVICE.getInstance(project)): Boolean {
+        if (fileIndex.isInSourceContent(file)) {
+            return !JetModuleTypeManager.getInstance()!!.isKtFileInGradleProjectInWrongFolder(file, project)
+        }
+
+        if (!includeLibrarySources) return false
+
+        return (withLibraryClassesRoots && fileIndex.isInLibraryClasses(file)) || fileIndex.isInLibrarySource(file)
+    }
+
+    platformStatic
+    public fun isInSource(element: PsiElement, includeLibrarySources: Boolean, withLibraryClassesRoots: Boolean = false): Boolean {
         return runReadAction { (): Boolean ->
             val containingFile = element.getContainingFile()
             if (containingFile == null) return@runReadAction false
@@ -32,8 +49,7 @@ public object ProjectRootsUtil {
             if (virtualFile == null) return@runReadAction false
 
             val project = element.getProject()
-            val index = ProjectFileIndex.SERVICE.getInstance(project)
-            return@runReadAction JetSourceFilterScope.isInProjectSources(project, virtualFile, index, false, includeLibrarySources)
+            return@runReadAction isInSources(project, virtualFile, includeLibrarySources, withLibraryClassesRoots)
         }!!
     }