Generic Java methods supported

idea/src/org/jetbrains/jet/lang/resolve/java/JavaClassMembersScope.java

@@ -1,5 +1,6 @@
 package org.jetbrains.jet.lang.resolve.java;
 
+import com.google.common.collect.Maps;
 import com.intellij.psi.*;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.JetScope;
@@ -8,6 +9,7 @@ import org.jetbrains.jet.lang.types.*;
 
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Map;
 
 /**
  * @author abreslav
@@ -17,6 +19,7 @@ public class JavaClassMembersScope implements JetScope {
     private final JavaSemanticServices semanticServices;
     private final boolean staticMembers;
     private final DeclarationDescriptor containingDeclaration;
+    private final Map<String, FunctionGroup> functionGroups = Maps.newHashMap();
 
     public JavaClassMembersScope(@NotNull DeclarationDescriptor classDescriptor, PsiClass psiClass, JavaSemanticServices semanticServices, boolean staticMembers) {
         this.containingDeclaration = classDescriptor;
@@ -78,31 +81,12 @@ public class JavaClassMembersScope implements JetScope {
     @NotNull
     @Override
     public FunctionGroup getFunctionGroup(@NotNull String name) {
-        WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(name);
+        FunctionGroup functionGroup = functionGroups.get(name);
-        PsiMethod[] allMethods = psiClass.getMethods(); // TODO : look into superclasses
+        if (functionGroup == null) {
-        for (PsiMethod method : allMethods) {
+            functionGroup = semanticServices.getDescriptorResolver().resolveFunctionGroup(psiClass, name, staticMembers);
-            if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
+            functionGroups.put(name, functionGroup);
-                continue;
-            }
-            if (!name.equals(method.getName())) {
-                 continue;
-            }
-            final PsiParameter[] parameters = method.getParameterList().getParameters();
-
-            FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
-                    JavaDescriptorResolver.JAVA_ROOT,
-                    Collections.<Attribute>emptyList(), // TODO
-                    name
-            );
-            functionDescriptor.initialize(
-                    Collections.<TypeParameterDescriptor>emptyList(), // TODO
-                    semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptor, parameters),
-                    semanticServices.getTypeTransformer().transformToType(method.getReturnType())
-            );
-            semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptor);
-            writableFunctionGroup.addFunction(functionDescriptor);
         }
-        return writableFunctionGroup;
+        return functionGroup;
     }
 
     @Override

idea/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java

@@ -88,7 +88,7 @@ public class JavaDescriptorResolver {
                 // TODO
                 modifierList == null ? false : modifierList.hasModifierProperty(PsiModifier.FINAL),
                 name,
-                resolveTypeParameters(psiClass, classDescriptor),
+                resolveTypeParameters(psiClass.getTypeParameters()),
                 supertypes
 
         ));
@@ -113,9 +113,8 @@ public class JavaDescriptorResolver {
         return classDescriptor;
     }
 
-    private List<TypeParameterDescriptor> resolveTypeParameters(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor) {
+    private List<TypeParameterDescriptor> resolveTypeParameters(@NotNull PsiTypeParameter[] typeParameters) {
         List<TypeParameterDescriptor> result = Lists.newArrayList();
-        PsiTypeParameter[] typeParameters = psiClass.getTypeParameters();
         for (PsiTypeParameter typeParameter : typeParameters) {
             TypeParameterDescriptor typeParameterDescriptor = resolveTypeParameter(typeParameter);
             result.add(typeParameterDescriptor);
@@ -238,4 +237,33 @@ public class JavaDescriptorResolver {
         }
         return result;
     }
+
+    @NotNull
+    public FunctionGroup resolveFunctionGroup(@NotNull PsiClass psiClass, @NotNull String methodName, boolean staticMembers) {
+        WritableFunctionGroup writableFunctionGroup = new WritableFunctionGroup(methodName);
+        PsiMethod[] allMethods = psiClass.getMethods(); // TODO : look into superclasses
+        for (PsiMethod method : allMethods) {
+            if (method.hasModifierProperty(PsiModifier.STATIC) != staticMembers) {
+                continue;
+            }
+            if (!methodName.equals(method.getName())) {
+                 continue;
+            }
+            final PsiParameter[] parameters = method.getParameterList().getParameters();
+
+            FunctionDescriptorImpl functionDescriptor = new FunctionDescriptorImpl(
+                    JavaDescriptorResolver.JAVA_ROOT,
+                    Collections.<Attribute>emptyList(), // TODO
+                    methodName
+            );
+            functionDescriptor.initialize(
+                    resolveTypeParameters(method.getTypeParameters()),
+                    semanticServices.getDescriptorResolver().resolveParameterDescriptors(functionDescriptor, parameters),
+                    semanticServices.getTypeTransformer().transformToType(method.getReturnType())
+            );
+            semanticServices.getTrace().recordDeclarationResolution(method, functionDescriptor);
+            writableFunctionGroup.addFunction(functionDescriptor);
+        }
+        return writableFunctionGroup;
+    }
 }

idea/testData/checker/ResolveToJava.jet

@@ -10,4 +10,12 @@ fun test(l : java.util.List<Int>) {
   val b : java.lang.Object
   val a : util.List<Int>
   val z : java.<error>utils</error>.List<Int>
+
+  val f : java.io.File? = null
+
+  Collections.<error>emptyList</error>
+  Collections.emptyList<Int>
+  Collections.emptyList<Int>()
+  Collections.emptyList<error>()</error>
+
 }