J2K KotlinSourceFilterScope: autoconvert

2016-06-09 21:47:21 +03:00
parent ddb3327992
commit a461dd0da2
1 changed files with 61 additions and 84 deletions
@@ -14,105 +14,82 @@
 * limitations under the License.
 */

-package org.jetbrains.kotlin.idea.stubindex;
+package org.jetbrains.kotlin.idea.stubindex

-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ProjectFileIndex;
-import com.intellij.openapi.roots.ProjectRootManager;
-import com.intellij.openapi.util.Ref;
-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.kotlin.idea.util.ProjectRootsUtil;
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.roots.ProjectFileIndex
+import com.intellij.openapi.roots.ProjectRootManager
+import com.intellij.openapi.util.Ref
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.psi.search.DelegatingGlobalSearchScope
+import com.intellij.psi.search.GlobalSearchScope
+import org.jetbrains.kotlin.idea.util.ProjectRootsUtil

-public class KotlinSourceFilterScope extends DelegatingGlobalSearchScope {
-    @NotNull
-    public static GlobalSearchScope sourcesAndLibraries(@NotNull GlobalSearchScope delegate, @NotNull Project project) {
-        return create(delegate, true, true, true, project);
+class KotlinSourceFilterScope private constructor(
+        delegate: GlobalSearchScope,
+        private val includeProjectSourceFiles: Boolean,
+        private val includeLibrarySourceFiles: Boolean,
+        private val includeClassFiles: Boolean,
+        private val project: Project) : DelegatingGlobalSearchScope(delegate) {
+
+    private val index = ProjectRootManager.getInstance(project).fileIndex
+
+    //NOTE: avoid recomputing in potentially bottleneck 'contains' method
+    private val isJsProjectRef = Ref<Boolean?>(null)
+
+    override fun getProject(): Project? {
+        return project
    }

-    @NotNull
-    public static GlobalSearchScope sourceAndClassFiles(@NotNull GlobalSearchScope delegate, @NotNull Project project) {
-        return create(delegate, true, false, true, project);
+    override fun contains(file: VirtualFile): Boolean {
+        if (!super.contains(file)) return false
+        return ProjectRootsUtil.isInContent(
+                project, file, includeProjectSourceFiles, includeLibrarySourceFiles, includeClassFiles, index, isJsProjectRef)
    }

-    @NotNull
-    public static GlobalSearchScope sources(@NotNull GlobalSearchScope delegate, @NotNull Project project) {
-        return create(delegate, true, false, false, project);
-    }
+    companion object {
+        fun sourcesAndLibraries(delegate: GlobalSearchScope, project: Project): GlobalSearchScope {
+            return create(delegate, true, true, true, project)
+        }

-    @NotNull
-    public static GlobalSearchScope librarySources(@NotNull GlobalSearchScope delegate, @NotNull Project project) {
-        return create(delegate, false, true, false, project);
-    }
+        fun sourceAndClassFiles(delegate: GlobalSearchScope, project: Project): GlobalSearchScope {
+            return create(delegate, true, false, true, project)
+        }

-    @NotNull
-    public static GlobalSearchScope libraryClassFiles(@NotNull GlobalSearchScope delegate, @NotNull Project project) {
-        return create(delegate, false, false, true, project);
-    }
+        fun sources(delegate: GlobalSearchScope, project: Project): GlobalSearchScope {
+            return create(delegate, true, false, false, project)
+        }

-    @NotNull
-    private static GlobalSearchScope create(
-            @NotNull GlobalSearchScope delegate,
-            boolean includeProjectSourceFiles,
-            boolean includeLibrarySourceFiles,
-            boolean includeClassFiles,
-            @NotNull Project project
-    ) {
-        if (delegate == GlobalSearchScope.EMPTY_SCOPE) return delegate;
+        fun librarySources(delegate: GlobalSearchScope, project: Project): GlobalSearchScope {
+            return create(delegate, false, true, false, project)
+        }

-        if (delegate instanceof KotlinSourceFilterScope) {
-            KotlinSourceFilterScope wrappedDelegate = (KotlinSourceFilterScope) delegate;
+        fun libraryClassFiles(delegate: GlobalSearchScope, project: Project): GlobalSearchScope {
+            return create(delegate, false, false, true, project)
+        }

-            boolean doIncludeProjectSourceFiles = wrappedDelegate.includeProjectSourceFiles && includeProjectSourceFiles;
-            boolean doIncludeLibrarySourceFiles = wrappedDelegate.includeLibrarySourceFiles && includeLibrarySourceFiles;
-            boolean doIncludeClassFiles = wrappedDelegate.includeClassFiles && includeClassFiles;
+        private fun create(
+                delegate: GlobalSearchScope,
+                includeProjectSourceFiles: Boolean,
+                includeLibrarySourceFiles: Boolean,
+                includeClassFiles: Boolean,
+                project: Project): GlobalSearchScope {
+            if (delegate === GlobalSearchScope.EMPTY_SCOPE) return delegate

-            return new KotlinSourceFilterScope(wrappedDelegate.myBaseScope,
+            if (delegate is KotlinSourceFilterScope) {
+
+                val doIncludeProjectSourceFiles = delegate.includeProjectSourceFiles && includeProjectSourceFiles
+                val doIncludeLibrarySourceFiles = delegate.includeLibrarySourceFiles && includeLibrarySourceFiles
+                val doIncludeClassFiles = delegate.includeClassFiles && includeClassFiles
+
+                return KotlinSourceFilterScope(delegate.myBaseScope,
                                               doIncludeProjectSourceFiles,
                                               doIncludeLibrarySourceFiles,
                                               doIncludeClassFiles,
-                                               project);
+                                               project)
+            }
+
+            return KotlinSourceFilterScope(delegate, includeProjectSourceFiles, includeLibrarySourceFiles, includeClassFiles, project)
        }
-
-        return new KotlinSourceFilterScope(delegate, includeProjectSourceFiles, includeLibrarySourceFiles, includeClassFiles, project);
-    }
-
-    private final ProjectFileIndex index;
-    private final Project project;
-    private final boolean includeProjectSourceFiles;
-    private final boolean includeLibrarySourceFiles;
-    private final boolean includeClassFiles;
-
-    //NOTE: avoid recomputing in potentially bottleneck 'contains' method
-    private final Ref<Boolean> isJsProjectRef = new Ref<Boolean>();
-
-    private KotlinSourceFilterScope(
-            @NotNull GlobalSearchScope delegate,
-            boolean includeProjectSourceFiles,
-            boolean includeLibrarySourceFiles,
-            boolean includeClassFiles,
-            @NotNull Project project
-    ) {
-        super(delegate);
-        this.project = project;
-        this.includeProjectSourceFiles = includeProjectSourceFiles;
-        this.includeLibrarySourceFiles = includeLibrarySourceFiles;
-        this.includeClassFiles = includeClassFiles;
-        this.index = ProjectRootManager.getInstance(project).getFileIndex();
-    }
-
-    @Override
-    public Project getProject() {
-        return project;
-    }
-
-    @Override
-    public boolean contains(@NotNull VirtualFile file) {
-        if (!super.contains(file)) return false;
-        return ProjectRootsUtil.isInContent(
-                project, file, includeProjectSourceFiles, includeLibrarySourceFiles, includeClassFiles, index, isJsProjectRef
-        );
    }
 }