Rewrote CallableDescriptorCollectors to Kotlin

compiler/frontend/src/org/jetbrains/jet/lang/resolve/LibrarySourceHacks.java

@@ -20,6 +20,7 @@ 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.jet.lang.descriptors.CallableDescriptor;
 import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
 import org.jetbrains.jet.lang.descriptors.PackageFragmentDescriptor;
@@ -36,6 +37,7 @@ public class 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) {

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/CallResolver.java

@@ -35,6 +35,7 @@ import org.jetbrains.jet.lang.resolve.calls.results.OverloadResolutionResultsImp
 import org.jetbrains.jet.lang.resolve.calls.results.ResolutionResultsHandler;
 import org.jetbrains.jet.lang.resolve.calls.smartcasts.DataFlowInfo;
 import org.jetbrains.jet.lang.resolve.calls.tasks.*;
+import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollectors;
 import org.jetbrains.jet.lang.resolve.calls.util.CallMaker;
 import org.jetbrains.jet.lang.resolve.calls.util.DelegatingCall;
 import org.jetbrains.jet.lang.resolve.name.Name;

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/CallableDescriptorCollector.java

@@ -1,37 +0,0 @@
-/*
- * Copyright 2010-2013 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.jet.lang.resolve.calls.tasks;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.descriptors.CallableDescriptor;
-import org.jetbrains.jet.lang.resolve.BindingTrace;
-import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.types.JetType;
-
-import java.util.Collection;
-
-public interface CallableDescriptorCollector<D extends CallableDescriptor> {
-    @NotNull
-    Collection<D> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace);
-
-    @NotNull
-    Collection<D> getMembersByName(@NotNull JetType receiver, Name name, @NotNull BindingTrace bindingTrace);
-
-    @NotNull
-    Collection<D> getNonMembersByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace);
-}

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

@@ -14,221 +14,139 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.lang.resolve.calls.tasks;
+package org.jetbrains.jet.lang.resolve.calls.tasks.collectors
 
-import com.google.common.collect.Lists;
+import org.jetbrains.jet.lang.descriptors.*
-import com.google.common.collect.Sets;
+import org.jetbrains.jet.lang.resolve.BindingTrace
-import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.calls.util.FakeCallableDescriptorForObject
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.resolve.name.Name
-import org.jetbrains.jet.lang.resolve.BindingTrace;
+import org.jetbrains.jet.lang.resolve.scopes.JetScope
-import org.jetbrains.jet.lang.resolve.calls.util.FakeCallableDescriptorForObject;
+import org.jetbrains.jet.lang.types.ErrorUtils
-import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.lang.types.JetType
-import org.jetbrains.jet.lang.resolve.scopes.JetScope;
-import org.jetbrains.jet.lang.types.ErrorUtils;
-import org.jetbrains.jet.lang.types.JetType;
 
-import java.util.*;
+import org.jetbrains.jet.lang.resolve.LibrarySourceHacks.filterOutMembersFromLibrarySource
 
-import static org.jetbrains.jet.lang.resolve.LibrarySourceHacks.filterOutMembersFromLibrarySource;
+public trait CallableDescriptorCollector<D : CallableDescriptor> {
 
-@SuppressWarnings("unchecked")
+    public fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D>
-public class CallableDescriptorCollectors<D extends CallableDescriptor> implements Iterable<CallableDescriptorCollector<D>> {
-    private static final CallableDescriptorCollector<FunctionDescriptor> FUNCTIONS_COLLECTOR =
-            new FilteredCollector<FunctionDescriptor>(new FunctionCollector());
-    private static final CallableDescriptorCollector<VariableDescriptor> VARIABLES_COLLECTOR =
-            new FilteredCollector<VariableDescriptor>(new VariableCollector());
-    private static final CallableDescriptorCollector<VariableDescriptor> PROPERTIES_COLLECTOR =
-            new FilteredCollector<VariableDescriptor>(new PropertyCollector());
 
-    public static final CallableDescriptorCollectors<CallableDescriptor> FUNCTIONS_AND_VARIABLES =
+    public fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D>
-            new CallableDescriptorCollectors(FUNCTIONS_COLLECTOR, VARIABLES_COLLECTOR);
-    public static final CallableDescriptorCollectors<CallableDescriptor> FUNCTIONS =
-            new CallableDescriptorCollectors(FUNCTIONS_COLLECTOR);
-    public static final CallableDescriptorCollectors<VariableDescriptor> VARIABLES =
-            new CallableDescriptorCollectors(VARIABLES_COLLECTOR);
-    public static final CallableDescriptorCollectors<VariableDescriptor> PROPERTIES =
-            new CallableDescriptorCollectors(PROPERTIES_COLLECTOR);
 
-    private static class FunctionCollector implements CallableDescriptorCollector<FunctionDescriptor> {
+    public fun getNonMembersByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D>
+}
 
-        @NotNull
+private val FUNCTIONS_COLLECTOR = FilteredCollector(FunctionCollector)
-        @Override
+private val VARIABLES_COLLECTOR = FilteredCollector(VariableCollector)
-        public Collection<FunctionDescriptor> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
+private val PROPERTIES_COLLECTOR = FilteredCollector(PropertyCollector)
-            Set<FunctionDescriptor> functions = Sets.newLinkedHashSet();
-            for (FunctionDescriptor function : scope.getFunctions(name)) {
-                if (function.getExtensionReceiverParameter() == null) {
-                    functions.add(function);
-                }
-            }
-            addConstructors(scope, name, functions);
-            return functions;
-        }
 
-        @NotNull
+public class CallableDescriptorCollectors<D : CallableDescriptor>(vararg collectors: CallableDescriptorCollector<D>) : Iterable<CallableDescriptorCollector<D>> {
-        @Override
+    private val collectors = collectors.toList()
-        public Collection<FunctionDescriptor> getMembersByName(@NotNull JetType receiverType, Name name, @NotNull BindingTrace bindingTrace) {
+    override fun iterator(): Iterator<CallableDescriptorCollector<D>> = collectors.iterator()
-            JetScope receiverScope = receiverType.getMemberScope();
-            Set<FunctionDescriptor> members = Sets.newHashSet(receiverScope.getFunctions(name));
-            addConstructors(receiverScope, name, members);
-            return members;
-        }
 
-        @NotNull
+    [suppress("UNCHECKED_CAST")]
-        @Override
+    class object {
-        public Collection<FunctionDescriptor> getNonMembersByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
+        public val FUNCTIONS_AND_VARIABLES: CallableDescriptorCollectors<CallableDescriptor> =
-            return scope.getFunctions(name);
+                CallableDescriptorCollectors(FUNCTIONS_COLLECTOR as CallableDescriptorCollector<CallableDescriptor>,
-        }
+                                             VARIABLES_COLLECTOR as CallableDescriptorCollector<CallableDescriptor>)
-
+        public val FUNCTIONS: CallableDescriptorCollectors<CallableDescriptor> =
-        private static void addConstructors(JetScope scope, Name name, Collection<FunctionDescriptor> functions) {
+                CallableDescriptorCollectors(FUNCTIONS_COLLECTOR as CallableDescriptorCollector<CallableDescriptor>)
-            ClassifierDescriptor classifier = scope.getClassifier(name);
+        public val VARIABLES: CallableDescriptorCollectors<VariableDescriptor> = CallableDescriptorCollectors(VARIABLES_COLLECTOR)
-            if (!(classifier instanceof ClassDescriptor) || ErrorUtils.isError(classifier)) return;
+        public val PROPERTIES: CallableDescriptorCollectors<VariableDescriptor> = CallableDescriptorCollectors(PROPERTIES_COLLECTOR)
-            ClassDescriptor classDescriptor = (ClassDescriptor) classifier;
+    }
-            if (classDescriptor.getKind().isSingleton()) {
+}
-                // Constructors of singletons shouldn't be callable from the code
+
-                return;
+private object FunctionCollector : CallableDescriptorCollector<FunctionDescriptor> {
-            }
+
-            functions.addAll(classDescriptor.getConstructors());
+    override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<FunctionDescriptor> {
-        }
+        return scope.getFunctions(name).filter { it.getExtensionReceiverParameter() == null } + getConstructors(scope, name)
-
+    }
-        @Override
+
-        public String toString() {
+    override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<FunctionDescriptor> {
-            return "FUNCTIONS";
+        val receiverScope = receiver.getMemberScope()
-        }
+        return receiverScope.getFunctions(name) + getConstructors(receiverScope, name)
-    }
+    }
-
+
-    private static class VariableCollector implements CallableDescriptorCollector<VariableDescriptor> {
+    override fun getNonMembersByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<FunctionDescriptor> {
-
+        return scope.getFunctions(name)
-        private static void addFakeDescriptorForObject(JetScope scope, Name name, Collection<VariableDescriptor> variables) {
+    }
-            ClassifierDescriptor classifier = scope.getClassifier(name);
+
-            if (!(classifier instanceof ClassDescriptor)) return;
+    private fun getConstructors(scope: JetScope, name: Name): Collection<FunctionDescriptor> {
-            JetType classObjectType = classifier.getClassObjectType();
+        val classifier = scope.getClassifier(name)
-            if (classObjectType == null) return;
+        if (classifier !is ClassDescriptor || ErrorUtils.isError(classifier)
-
+            // Constructors of singletons shouldn't be callable from the code
-            variables.add(new FakeCallableDescriptorForObject((ClassDescriptor) classifier));
+            || classifier.getKind().isSingleton()) {
-        }
+            return listOf()
-
+        }
-        @NotNull
+        return classifier.getConstructors()
-        @Override
+    }
-        public Collection<VariableDescriptor> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
+
-            VariableDescriptor localVariable = scope.getLocalVariable(name);
+    override fun toString() = "FUNCTIONS"
-            if (localVariable != null) {
+}
-                return Collections.singleton(localVariable);
+
-            }
+private object VariableCollector : CallableDescriptorCollector<VariableDescriptor> {
-
+
-            Set<VariableDescriptor> variables = Sets.newLinkedHashSet();
+    private fun getFakeDescriptorForObject(scope: JetScope, name: Name): VariableDescriptor? {
-            for (VariableDescriptor variable : scope.getProperties(name)) {
+        val classifier = scope.getClassifier(name)
-                if (variable.getExtensionReceiverParameter() == null) {
+        if (classifier !is ClassDescriptor || classifier.getClassObjectType() == null) return null
-                    variables.add(variable);
+
-                }
+        return FakeCallableDescriptorForObject(classifier as ClassDescriptor)
-            }
+    }
-            addFakeDescriptorForObject(scope, name, variables);
+
-            return variables;
+    override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-        }
+        val localVariable = scope.getLocalVariable(name)
-
+        if (localVariable != null) {
-        @NotNull
+            return setOf(localVariable)
-        @Override
+        }
-        public Collection<VariableDescriptor> getMembersByName(@NotNull JetType receiverType, Name name, @NotNull BindingTrace bindingTrace) {
+        return (scope.getProperties(name).filter { it.getExtensionReceiverParameter() == null } + getFakeDescriptorForObject(scope, name))
-            JetScope memberScope = receiverType.getMemberScope();
+                .filterNotNull()
-            Collection<VariableDescriptor> members = Lists.newArrayList();
+    }
-            members.addAll(memberScope.getProperties(name));
+
-            addFakeDescriptorForObject(memberScope, name, members);
+    override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-            return members;
+        val memberScope = receiver.getMemberScope()
-        }
+        return (memberScope.getProperties(name) + getFakeDescriptorForObject(memberScope, name)).filterNotNull()
-
+    }
-        @NotNull
+
-        @Override
+    override fun getNonMembersByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-        public Collection<VariableDescriptor> getNonMembersByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
+        return (listOf(scope.getLocalVariable(name)) + scope.getProperties(name)).filterNotNull()
-            Collection<VariableDescriptor> result = Sets.newLinkedHashSet();
+    }
-
+
-            VariableDescriptor localVariable = scope.getLocalVariable(name);
+    override fun toString() = "VARIABLES"
-            if (localVariable != null) {
+}
-                result.add(localVariable);
+
-            }
+private object PropertyCollector : CallableDescriptorCollector<VariableDescriptor> {
-            result.addAll(scope.getProperties(name));
+    private fun filterProperties(variableDescriptors: Collection<VariableDescriptor>) =
-            return result;
+            variableDescriptors.filter { it is PropertyDescriptor }
-        }
+
-
+    override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-        @Override
+        return filterProperties(VARIABLES_COLLECTOR.getNonExtensionsByName(scope, name, bindingTrace))
-        public String toString() {
+    }
-            return "VARIABLES";
+
-        }
+    override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-    }
+        return filterProperties(VARIABLES_COLLECTOR.getMembersByName(receiver, name, bindingTrace))
-
+    }
-    private static class PropertyCollector implements CallableDescriptorCollector<VariableDescriptor> {
+
-        private static Collection<VariableDescriptor> filterProperties(Collection<? extends VariableDescriptor> variableDescriptors) {
+    override fun getNonMembersByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<VariableDescriptor> {
-            List<VariableDescriptor> properties = Lists.newArrayList();
+        return filterProperties(VARIABLES_COLLECTOR.getNonMembersByName(scope, name, bindingTrace))
-            for (VariableDescriptor descriptor : variableDescriptors) {
+    }
-                if (descriptor instanceof PropertyDescriptor) {
+
-                    properties.add(descriptor);
+    override fun toString() = "PROPERTIES"
-                }
+}
-            }
+
-            return properties;
+private class FilteredCollector<D : CallableDescriptor>(private val delegate: CallableDescriptorCollector<D>) : CallableDescriptorCollector<D> {
-        }
+
-
+    override fun getNonExtensionsByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        @NotNull
+        return filterOutMembersFromLibrarySource(delegate.getNonExtensionsByName(scope, name, bindingTrace))
-        @Override
+    }
-        public Collection<VariableDescriptor> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
+
-            return filterProperties(VARIABLES_COLLECTOR.getNonExtensionsByName(scope, name, bindingTrace));
+    override fun getMembersByName(receiver: JetType, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        }
+        return filterOutMembersFromLibrarySource(delegate.getMembersByName(receiver, name, bindingTrace))
-
+    }
-        @NotNull
+
-        @Override
+    override fun getNonMembersByName(scope: JetScope, name: Name, bindingTrace: BindingTrace): Collection<D> {
-        public Collection<VariableDescriptor> getMembersByName(@NotNull JetType receiver, Name name, @NotNull BindingTrace bindingTrace) {
+        return filterOutMembersFromLibrarySource(delegate.getNonMembersByName(scope, name, bindingTrace))
-            return filterProperties(VARIABLES_COLLECTOR.getMembersByName(receiver, name, bindingTrace));
+    }
-        }
+
-
+    override fun toString(): String {
-        @NotNull
+        return delegate.toString()
-        @Override
-        public Collection<VariableDescriptor> getNonMembersByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
-            return filterProperties(VARIABLES_COLLECTOR.getNonMembersByName(scope, name, bindingTrace));
-        }
-
-        @Override
-        public String toString() {
-            return "PROPERTIES";
-        }
-    }
-    
-    private static class FilteredCollector<D extends CallableDescriptor> implements CallableDescriptorCollector<D> {
-        private final CallableDescriptorCollector<D> delegate;
-
-        private FilteredCollector(CallableDescriptorCollector<D> delegate) {
-            this.delegate = delegate;
-        }
-
-        @NotNull
-        @Override
-        public Collection<D> getNonExtensionsByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
-            return filterOutMembersFromLibrarySource(delegate.getNonExtensionsByName(scope, name, bindingTrace));
-        }
-
-        @NotNull
-        @Override
-        public Collection<D> getMembersByName(@NotNull JetType receiver, Name name, @NotNull BindingTrace bindingTrace) {
-            return filterOutMembersFromLibrarySource(delegate.getMembersByName(receiver, name, bindingTrace));
-        }
-
-        @NotNull
-        @Override
-        public Collection<D> getNonMembersByName(JetScope scope, Name name, @NotNull BindingTrace bindingTrace) {
-            return filterOutMembersFromLibrarySource(delegate.getNonMembersByName(scope, name, bindingTrace));
-        }
-
-        @Override
-        public String toString() {
-            return delegate.toString();
-        }
-    }
-
-    private final Collection<CallableDescriptorCollector<D>> collectors;
-
-    private CallableDescriptorCollectors(CallableDescriptorCollector<D>... collectors) {
-        this.collectors = Lists.newArrayList(collectors);
-    }
-
-    @NotNull
-    @Override
-    public Iterator<CallableDescriptorCollector<D>> iterator() {
-        return collectors.iterator();
     }
 }

compiler/frontend/src/org/jetbrains/jet/lang/resolve/calls/tasks/TaskPrioritizer.java

@@ -27,6 +27,8 @@ import org.jetbrains.jet.lang.psi.JetExpression;
 import org.jetbrains.jet.lang.psi.JetSuperExpression;
 import org.jetbrains.jet.lang.resolve.calls.context.BasicCallResolutionContext;
 import org.jetbrains.jet.lang.resolve.calls.smartcasts.SmartCastUtils;
+import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollector;
+import org.jetbrains.jet.lang.resolve.calls.tasks.collectors.CallableDescriptorCollectors;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.lang.resolve.scopes.JetScope;
 import org.jetbrains.jet.lang.resolve.scopes.JetScopeUtils;