Extracted method to util class and replaced parameter to Project.

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/CompileEnvironmentUtil.java

@@ -16,12 +16,23 @@
 
 package org.jetbrains.jet.cli.jvm.compiler;
 
+import com.google.common.collect.Lists;
 import com.intellij.openapi.Disposable;
+import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.util.io.FileUtil;
 import com.intellij.openapi.util.io.FileUtilRt;
+import com.intellij.openapi.vfs.StandardFileSystems;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.VirtualFileManager;
+import com.intellij.openapi.vfs.VirtualFileSystem;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
 import com.intellij.util.Function;
 import com.intellij.util.containers.ContainerUtil;
+import kotlin.Function1;
+import kotlin.Unit;
+import kotlin.io.IoPackage;
 import kotlin.modules.AllModules;
 import kotlin.modules.Module;
 import org.jetbrains.annotations.NotNull;
@@ -39,8 +50,10 @@ import org.jetbrains.jet.codegen.GeneratedClassLoader;
 import org.jetbrains.jet.codegen.state.GenerationState;
 import org.jetbrains.jet.config.CommonConfigurationKeys;
 import org.jetbrains.jet.config.CompilerConfiguration;
+import org.jetbrains.jet.lang.psi.JetFile;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.plugin.JetFileType;
 import org.jetbrains.jet.utils.KotlinPaths;
 import org.jetbrains.jet.utils.PathUtil;
 import org.jetbrains.jet.utils.UtilsPackage;
@@ -266,6 +279,51 @@ public class CompileEnvironmentUtil {
         }
     }
 
+    @NotNull
+    public static List<JetFile> getJetFiles(
+            @NotNull final Project project,
+            @NotNull List<String> sourceRoots,
+            @NotNull Function1<String, Unit> reportError
+    ) {
+        final VirtualFileSystem localFileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL);
+
+        final List<JetFile> result = Lists.newArrayList();
+
+        for (String sourceRootPath : sourceRoots) {
+            if (sourceRootPath == null) {
+                continue;
+            }
+
+            VirtualFile vFile = localFileSystem.findFileByPath(sourceRootPath);
+            if (vFile == null) {
+                reportError.invoke("Source file or directory not found: " + sourceRootPath);
+                continue;
+            }
+            if (!vFile.isDirectory() && vFile.getFileType() != JetFileType.INSTANCE) {
+                reportError.invoke("Source entry is not a Kotlin file: " + sourceRootPath);
+                continue;
+            }
+
+            IoPackage.recurse(new File(sourceRootPath), new Function1<File, Unit>() {
+                @Override
+                public Unit invoke(File file) {
+                    if (file.isFile()) {
+                        VirtualFile fileByPath = localFileSystem.findFileByPath(file.getAbsolutePath());
+                        if (fileByPath != null) {
+                            PsiFile psiFile = PsiManager.getInstance(project).findFile(fileByPath);
+                            if (psiFile instanceof JetFile) {
+                                result.add((JetFile) psiFile);
+                            }
+                        }
+                    }
+                    return Unit.VALUE;
+                }
+            });
+        }
+
+        return result;
+    }
+
     private static class DescriptionToModuleAdapter implements Module {
         private final ModuleDescription description;
 

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/JetCoreEnvironment.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.cli.jvm.compiler;
 
-import com.google.common.collect.Lists;
 import com.intellij.codeInsight.ExternalAnnotationsManager;
 import com.intellij.core.CoreApplicationEnvironment;
 import com.intellij.core.CoreJavaFileManager;
@@ -33,14 +32,12 @@ import com.intellij.openapi.project.Project;
 import com.intellij.openapi.util.Disposer;
 import com.intellij.openapi.vfs.VirtualFile;
 import com.intellij.psi.PsiElementFinder;
-import com.intellij.psi.PsiFile;
 import com.intellij.psi.PsiManager;
 import com.intellij.psi.compiled.ClassFileDecompilers;
 import com.intellij.psi.impl.compiled.ClsCustomNavigationPolicy;
 import com.intellij.psi.impl.file.impl.JavaFileManager;
 import kotlin.Function1;
 import kotlin.Unit;
-import kotlin.io.IoPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.TestOnly;
 import org.jetbrains.jet.CompilerModeProvider;
@@ -207,13 +204,14 @@ public class JetCoreEnvironment {
             addExternalAnnotationsRoot(path);
         }
         sourceFiles.addAll(
-                getJetFiles(this, configuration.getList(CommonConfigurationKeys.SOURCE_ROOTS_KEY), new Function1<String, Unit>() {
+                CompileEnvironmentUtil
-                    @Override
+                        .getJetFiles(getProject(), configuration.getList(CommonConfigurationKeys.SOURCE_ROOTS_KEY), new Function1<String, Unit>() {
-                    public Unit invoke(String s) {
+                            @Override
-                        report(ERROR, s);
+                            public Unit invoke(String s) {
-                        return null;
+                                report(ERROR, s);
-                    }
+                                return Unit.VALUE;
-                }));
+                            }
+                        }));
 
         JetScriptDefinitionProvider.getInstance(project).addScriptDefinitions(
                 configuration.getList(CommonConfigurationKeys.SCRIPT_DEFINITIONS_KEY));
@@ -248,45 +246,6 @@ public class JetCoreEnvironment {
         annotationsManager.addExternalAnnotationsRoot(PathUtil.jarFileOrDirectoryToVirtualFile(path));
     }
 
-    @NotNull
-    public static List<JetFile> getJetFiles(@NotNull final JetCoreEnvironment environment, @NotNull List<String> sourceRoots, @NotNull Function1<String, Unit> reportError) {
-        final List<JetFile> result = Lists.newArrayList();
-
-        for (String sourceRootPath : sourceRoots) {
-            if (sourceRootPath == null) {
-                continue;
-            }
-
-            VirtualFile vFile = environment.getMyApplicationEnvironment().getLocalFileSystem().findFileByPath(sourceRootPath);
-            if (vFile == null) {
-                reportError.invoke("Source file or directory not found: " + sourceRootPath);
-                continue;
-            }
-            if (!vFile.isDirectory() && vFile.getFileType() != JetFileType.INSTANCE) {
-                reportError.invoke("Source entry is not a Kotlin file: " + sourceRootPath);
-                continue;
-            }
-
-            IoPackage.recurse(new File(sourceRootPath), new Function1<File, Unit>() {
-                @Override
-                public Unit invoke(File file) {
-                    if (file.isFile()) {
-                        VirtualFile fileByPath = environment.getMyApplicationEnvironment().getLocalFileSystem().findFileByPath(file.getAbsolutePath());
-                        if (fileByPath != null) {
-                            PsiFile psiFile = PsiManager.getInstance(environment.getProject()).findFile(fileByPath);
-                            if (psiFile instanceof JetFile) {
-                                result.add((JetFile) psiFile);
-                            }
-                        }
-                    }
-                    return null;
-                }
-            });
-        }
-
-        return result;
-    }
-
     private void addToClasspath(File path) {
         if (path.isFile()) {
             VirtualFile jarFile = getMyApplicationEnvironment().getJarFileSystem().findFileByPath(path + "!/");

compiler/cli/src/org/jetbrains/jet/cli/jvm/compiler/KotlinToJVMBytecodeCompiler.java

@@ -121,13 +121,14 @@ public class KotlinToJVMBytecodeCompiler {
             exhaust.throwIfError();
 
             for (Module module : chunk) {
-                List<JetFile> jetFiles = JetCoreEnvironment.getJetFiles(
+                List<JetFile> jetFiles = CompileEnvironmentUtil.getJetFiles(
-                        environment, getAbsolutePaths(directory, module), new Function1<String, Unit>() {
+                        environment.getProject(), getAbsolutePaths(directory, module), new Function1<String, Unit>() {
                             @Override
                             public Unit invoke(String s) {
                                 throw new IllegalStateException("Should have been checked before: " + s);
                             }
-                        });
+                        }
+                );
                 GenerationState generationState = generate(environment, exhaust, jetFiles);
                 outputFiles.put(module, generationState.getFactory());
             }