Java to Kotlin action: no infinite recursion for symlinks + more efficient update()

idea/src/org/jetbrains/jet/plugin/actions/JavaToKotlinAction.kt

@@ -39,10 +39,12 @@ import com.intellij.openapi.vfs.CharsetToolkit
 import org.jetbrains.jet.lang.psi.JetFile
 import org.jetbrains.jet.utils.addIfNotNull
 import org.jetbrains.jet.plugin.caches.resolve.getLazyResolveSession
+import com.intellij.openapi.vfs.VfsUtilCore
+import com.intellij.openapi.vfs.VirtualFileVisitor
 
 public class JavaToKotlinAction : AnAction() {
     override fun actionPerformed(e: AnActionEvent) {
-        val selectedJavaFiles = selectedJavaFiles(e)
+        val selectedJavaFiles = selectedJavaFiles(e).toList()
         val project = CommonDataKeys.PROJECT.getData(e.getDataContext())!!
 
         CommandProcessor.getInstance().executeCommand(project, object : Runnable {
@@ -59,46 +61,37 @@ public class JavaToKotlinAction : AnAction() {
     }
 
     override fun update(e: AnActionEvent) {
-        val enabled = selectedJavaFiles(e).isNotEmpty()
+        val enabled = selectedJavaFiles(e).any()
         e.getPresentation().setEnabled(enabled)
     }
 
-    private fun selectedJavaFiles(e: AnActionEvent): List<PsiJavaFile> {
+    private fun selectedJavaFiles(e: AnActionEvent): Stream<PsiJavaFile> {
-        val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return listOf()
+        val virtualFiles = e.getData(CommonDataKeys.VIRTUAL_FILE_ARRAY) ?: return streamOf()
-        val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return listOf()
+        val project = CommonDataKeys.PROJECT.getData(e.getDataContext()) ?: return streamOf()
         return allJavaFiles(virtualFiles, project)
     }
 
-    private fun allJavaFiles(filesOrDirs: Array<VirtualFile>, project: Project): List<PsiJavaFile> {
+    private fun allJavaFiles(filesOrDirs: Array<VirtualFile>, project: Project): Stream<PsiJavaFile> {
-        val allFiles = allFiles(filesOrDirs)
         val manager = PsiManager.getInstance(project)
-        val result = ArrayList<PsiJavaFile>()
+        return allFiles(filesOrDirs)
-        for (file in allFiles) {
+                .stream()
-            val psiFile = manager.findFile(file)
+                .map { manager.findFile(it) as? PsiJavaFile }
-            if (psiFile is PsiJavaFile) {
+                .filterNotNull()
-                result.add(psiFile)
-            }
-        }
-        return result
     }
 
     private fun allFiles(filesOrDirs: Array<VirtualFile>): Collection<VirtualFile> {
         val result = ArrayList<VirtualFile>()
-        filesOrDirs.forEach { result.addFilesRecursive(it) }
+        for (file in filesOrDirs) {
+            VfsUtilCore.visitChildrenRecursively(file, object : VirtualFileVisitor<Unit>() {
+                override fun visitFile(file: VirtualFile): Boolean {
+                    result.add(file)
+                    return true
+                }
+            })
+        }
         return result
     }
 
-    private fun MutableCollection<VirtualFile>.addFilesRecursive(root: VirtualFile) {
-        if (root.isDirectory()) {
-            root.getChildren()!!.forEach {
-                addFilesRecursive(it)
-            }
-        }
-        else {
-            add(root)
-        }
-    }
-
     private fun reformatFiles(kotlinFiles: List<VirtualFile>, project: Project) {
         for (file in kotlinFiles) {
             ApplicationManager.getApplication().runWriteAction {