Refactor: rework FilteredCollector in CallableDescriptorCollectors

Convert LibrarySourceHacks to Kotlin

compiler/frontend/src/org/jetbrains/kotlin/resolve/LibrarySourceHacks.java

@@ -1,67 +0,0 @@
-/*
- * Copyright 2010-2015 JetBrains s.r.o.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jetbrains.kotlin.resolve;
-
-import com.google.common.collect.Lists;
-import com.intellij.openapi.util.Key;
-import com.intellij.psi.PsiElement;
-import com.intellij.psi.PsiFile;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.kotlin.descriptors.CallableDescriptor;
-import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor;
-import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor;
-
-import java.util.Collection;
-import java.util.List;
-
-import static org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.callableDescriptorToDeclaration;
-
-public class LibrarySourceHacks {
-    private LibrarySourceHacks() {
-    }
-
-    public static final Key<Boolean> SKIP_TOP_LEVEL_MEMBERS = Key.create("SKIP_TOP_LEVEL_MEMBERS"); // used when analyzing library source
-
-
-    @NotNull
-    public static <D extends CallableDescriptor> List<D> filterOutMembersFromLibrarySource(Collection<D> members) {
-        List<D> filteredMembers = Lists.newArrayList();
-        for (D member : members) {
-            if (!shouldSkip(member)) {
-                filteredMembers.add(member);
-            }
-        }
-        return filteredMembers;
-    }
-
-    private static boolean shouldSkip(CallableDescriptor member) {
-        CallableDescriptor original = member.getOriginal();
-        if (!(original instanceof CallableMemberDescriptor)) {
-            return false;
-        }
-        if (!(original.getContainingDeclaration() instanceof PackageFragmentDescriptor)) {
-            return false;
-        }
-
-        PsiElement declaration = callableDescriptorToDeclaration((CallableMemberDescriptor) original);
-        if (declaration == null) {
-            return false;
-        }
-        PsiFile file = declaration.getContainingFile();
-        return file != null && Boolean.TRUE.equals(file.getUserData(SKIP_TOP_LEVEL_MEMBERS));
-    }
-}

compiler/frontend/src/org/jetbrains/kotlin/resolve/LibrarySourceHacks.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2010-2015 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jetbrains.kotlin.resolve
+
+import com.intellij.openapi.util.Key
+import org.jetbrains.kotlin.descriptors.CallableDescriptor
+import org.jetbrains.kotlin.descriptors.CallableMemberDescriptor
+import org.jetbrains.kotlin.descriptors.PackageFragmentDescriptor
+
+import org.jetbrains.kotlin.resolve.DescriptorToSourceUtils.callableDescriptorToDeclaration
+
+public object LibrarySourceHacks {
+    public val SKIP_TOP_LEVEL_MEMBERS: Key<Boolean> = Key.create<Boolean>("SKIP_TOP_LEVEL_MEMBERS") // used when analyzing library source
+
+    public fun shouldSkip(member: CallableDescriptor): Boolean {
+        val original = member.getOriginal() as? CallableMemberDescriptor ?: return false
+
+        if (original.getContainingDeclaration() !is PackageFragmentDescriptor) return false
+
+        val declaration = callableDescriptorToDeclaration(original) ?: return false
+
+        val file = declaration.getContainingFile()
+        return file != null && (file.getUserData<Boolean>(SKIP_TOP_LEVEL_MEMBERS) ?: false)
+    }
+}

compiler/frontend/src/org/jetbrains/kotlin/resolve/calls/tasks/CallableDescriptorCollectors.kt

@@ -17,15 +17,14 @@
 package org.jetbrains.kotlin.resolve.calls.tasks.collectors
 
 import org.jetbrains.kotlin.descriptors.*
-import org.jetbrains.kotlin.resolve.BindingTrace
 import org.jetbrains.kotlin.resolve.calls.util.FakeCallableDescriptorForObject
 import org.jetbrains.kotlin.name.Name
 import org.jetbrains.kotlin.resolve.scopes.JetScope
 import org.jetbrains.kotlin.types.ErrorUtils
 import org.jetbrains.kotlin.types.JetType
 
-import org.jetbrains.kotlin.resolve.LibrarySourceHacks.filterOutMembersFromLibrarySource
 import org.jetbrains.kotlin.resolve.DescriptorUtils.isStaticNestedClass
+import org.jetbrains.kotlin.resolve.*
 
 public trait CallableDescriptorCollector<D : CallableDescriptor> {
 
@@ -38,9 +37,11 @@ public trait CallableDescriptorCollector<D : CallableDescriptor> {
     public fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D>
 }
 
-private val FUNCTIONS_COLLECTOR = FilteredCollector(FunctionCollector)
+private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.withDefaultFilter() = filtered { !LibrarySourceHacks.shouldSkip(it) }
-private val VARIABLES_COLLECTOR = FilteredCollector(VariableCollector)
+
-private val PROPERTIES_COLLECTOR = FilteredCollector(PropertyCollector)
+private val FUNCTIONS_COLLECTOR = FunctionCollector.withDefaultFilter()
+private val VARIABLES_COLLECTOR = VariableCollector.withDefaultFilter()
+private val PROPERTIES_COLLECTOR = PropertyCollector.withDefaultFilter()
 
 public class CallableDescriptorCollectors<D : CallableDescriptor>(vararg collectors: CallableDescriptorCollector<D>) : Iterable<CallableDescriptorCollector<D>> {
     private val collectors = collectors.toList()
@@ -150,25 +151,27 @@ private object PropertyCollector : CallableDescriptorCollector<VariableDescripto
     override fun toString() = "PROPERTIES"
 }
 
-private class FilteredCollector<D : CallableDescriptor>(private val delegate: CallableDescriptorCollector<D>) : CallableDescriptorCollector<D> {
+private fun <D : CallableDescriptor> CallableDescriptorCollector<D>.filtered(filter: (D) -> Boolean): CallableDescriptorCollector<D> {
+    val delegate = this
+    return object : CallableDescriptorCollector<D> {
+        override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
+            return delegate.getNonExtensionsByName(scope, name, bindingTrace).filter(filter)
+        }
 
-    override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
+        override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        return filterOutMembersFromLibrarySource(delegate.getNonExtensionsByName(scope, name, bindingTrace))
+            return delegate.getMembersByName(receiver, name, bindingTrace).filter(filter)
-    }
+        }
 
-    override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D> {
+        override fun getStaticMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        return filterOutMembersFromLibrarySource(delegate.getMembersByName(receiver, name, bindingTrace))
+            return delegate.getStaticMembersByName(receiver, name, bindingTrace).filter(filter)
-    }
+        }
 
-    override fun getStaticMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D> {
+        override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        return filterOutMembersFromLibrarySource(delegate.getStaticMembersByName(receiver, name, bindingTrace))
+            return delegate.getExtensionsByName(scope, name, bindingTrace).filter(filter)
-    }
+        }
 
-    override fun getExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
+        override fun toString(): String {
-        return filterOutMembersFromLibrarySource(delegate.getExtensionsByName(scope, name, bindingTrace))
+            return delegate.toString()
+        }
     }
-
+}
-    override fun toString(): String {
-        return delegate.toString()
-    }
-}