Refactor JavaSignatureResolver

Now it has the only method returning Initializer, an object which can be told
to initialize resolved descriptors later, or to obtain these descriptors.
Delete useless methods, combine the remaining ones

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java

@@ -300,10 +300,9 @@ public final class JavaClassResolver {
 
         classDescriptor.setName(javaClass.getName());
 
-        List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
+        JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(classDescriptor, javaClass);
-                = JavaSignatureResolver.makeUninitializedTypeParameters(classDescriptor, javaClass.getTypeParameters());
+        classDescriptor.setTypeParameterDescriptors(typeParameterInitializer.getDescriptors());
 
-        classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations));
         List<JetType> supertypes = Lists.newArrayList();
         classDescriptor.setSupertypes(supertypes);
         classDescriptor.setVisibility(javaClass.getVisibility());
@@ -314,7 +313,7 @@ public final class JavaClassResolver {
         classDescriptor.setScopeForMemberLookup(scope);
         classDescriptor.setScopeForConstructorResolve(scope);
 
-        signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor);
+        typeParameterInitializer.initialize();
 
         // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes
         List<TypeParameterDescriptor> classTypeParameters = classDescriptor.getTypeConstructor().getParameters();
@@ -400,17 +399,6 @@ public final class JavaClassResolver {
         }
     }
 
-    @NotNull
-    private static List<TypeParameterDescriptor> getTypeParametersDescriptors(
-            @NotNull List<JavaSignatureResolver.TypeParameterDescriptorInitialization> typeParameterDescriptorInitializations
-    ) {
-        List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
-        for (JavaSignatureResolver.TypeParameterDescriptorInitialization typeParameter : typeParameterDescriptorInitializations) {
-            typeParameters.add(typeParameter.getDescriptor());
-        }
-        return typeParameters;
-    }
-
     private void checkFqNamesAreConsistent(@NotNull JavaClass javaClass, @NotNull FqName desiredFqName) {
         FqName fqName = javaClass.getFqName();
         assert desiredFqName.equals(fqName) : "Inconsistent FQ names: " + fqName + ", " + desiredFqName;

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java

@@ -126,8 +126,9 @@ public final class JavaFunctionResolver {
                 CallableMemberDescriptor.Kind.DECLARATION
         );
 
-        List<TypeParameterDescriptor> methodTypeParameters =
+        JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(functionDescriptorImpl, method);
-                signatureResolver.resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters());
+        typeParameterInitializer.initialize();
+        List<TypeParameterDescriptor> methodTypeParameters = typeParameterInitializer.getDescriptors();
 
         TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl);
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java

@@ -16,7 +16,6 @@
 
 package org.jetbrains.jet.lang.resolve.java.resolver;
 
-import com.google.common.collect.Lists;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
 import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
@@ -25,14 +24,12 @@ import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.TypeUsage;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter;
-import org.jetbrains.jet.lang.types.JetType;
+import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameterListOwner;
 import org.jetbrains.jet.lang.types.Variance;
 import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns;
 
 import javax.inject.Inject;
-import java.util.Collection;
+import java.util.*;
-import java.util.Collections;
-import java.util.List;
 
 public final class JavaSignatureResolver {
     @NotNull
@@ -43,104 +40,66 @@ public final class JavaSignatureResolver {
         this.typeTransformer = javaTypeTransformer;
     }
 
-    public static class TypeParameterDescriptorInitialization {
-        @NotNull
-        private final TypeParameterDescriptorImpl descriptor;
-        private final JavaTypeParameter javaTypeParameter;
-
-        private TypeParameterDescriptorInitialization(
-                @NotNull TypeParameterDescriptorImpl descriptor,
-                @NotNull JavaTypeParameter javaTypeParameter
-        ) {
-            this.descriptor = descriptor;
-            this.javaTypeParameter = javaTypeParameter;
-        }
-
-        @NotNull
-        public TypeParameterDescriptorImpl getDescriptor() {
-            return descriptor;
-        }
-    }
-
     @NotNull
-    public static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
+    public Initializer resolveTypeParameters(
-            @NotNull DeclarationDescriptor container,
+            @NotNull DeclarationDescriptor ownerDescriptor,
-            @NotNull Collection<JavaTypeParameter> typeParameters
+            @NotNull JavaTypeParameterListOwner typeParameterListOwner
     ) {
-        List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
+        Initializer result = new Initializer(ownerDescriptor);
-        for (JavaTypeParameter typeParameter : typeParameters) {
+        for (JavaTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) {
-            result.add(makeUninitializedTypeParameter(container, typeParameter));
+            result.addTypeParameter(typeParameter);
         }
         return result;
     }
 
-    @NotNull
+    public class Initializer {
-    private static TypeParameterDescriptorInitialization makeUninitializedTypeParameter(
+        private final DeclarationDescriptor owner;
-            @NotNull DeclarationDescriptor containingDeclaration,
+        private final List<TypeParameterDescriptor> descriptors = new ArrayList<TypeParameterDescriptor>();
-            @NotNull JavaTypeParameter typeParameter
+        private final List<JavaTypeParameter> javaTypeParameters = new ArrayList<JavaTypeParameter>();
-    ) {
-        TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification(
-                containingDeclaration,
-                Collections.<AnnotationDescriptor>emptyList(), // TODO
-                false,
-                Variance.INVARIANT,
-                typeParameter.getName(),
-                typeParameter.getIndex()
-        );
-        return new TypeParameterDescriptorInitialization(typeParameterDescriptor, typeParameter);
-    }
 
-    private void initializeTypeParameter(
+        private Initializer(@NotNull DeclarationDescriptor owner) {
-            @NotNull TypeParameterDescriptorInitialization initialization,
+            this.owner = owner;
-            @NotNull TypeVariableResolver typeVariableResolver
-    ) {
-        TypeParameterDescriptorImpl typeParameterDescriptor = initialization.descriptor;
-        Collection<JavaClassifierType> upperBounds = initialization.javaTypeParameter.getUpperBounds();
-        if (upperBounds.isEmpty()) {
-            typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType());
         }
-        else {
+
-            for (JavaClassifierType upperBound : upperBounds) {
+        private void addTypeParameter(@NotNull JavaTypeParameter typeParameter) {
-                JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver);
+            TypeParameterDescriptorImpl descriptor = TypeParameterDescriptorImpl.createForFurtherModification(
-                typeParameterDescriptor.addUpperBound(transformedType);
+                    owner,
+                    Collections.<AnnotationDescriptor>emptyList(), // TODO
+                    false,
+                    Variance.INVARIANT,
+                    typeParameter.getName(),
+                    typeParameter.getIndex()
+            );
+
+            descriptors.add(descriptor);
+            javaTypeParameters.add(typeParameter);
+        }
+
+        @NotNull
+        public List<TypeParameterDescriptor> getDescriptors() {
+            return descriptors;
+        }
+
+        public void initialize() {
+            TypeVariableResolver typeVariableResolver = new TypeVariableResolver(getDescriptors(), owner);
+
+            Iterator<TypeParameterDescriptor> descriptorIterator = descriptors.iterator();
+            Iterator<JavaTypeParameter> typeParameterIterator = javaTypeParameters.iterator();
+
+            while (descriptorIterator.hasNext()) {
+                TypeParameterDescriptorImpl descriptor = (TypeParameterDescriptorImpl) descriptorIterator.next();
+                Collection<JavaClassifierType> upperBounds = typeParameterIterator.next().getUpperBounds();
+
+                if (upperBounds.isEmpty()) {
+                    descriptor.addUpperBound(KotlinBuiltIns.getInstance().getDefaultBound());
+                }
+                else {
+                    for (JavaClassifierType upperBound : upperBounds) {
+                        descriptor.addUpperBound(typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver));
+                    }
+                }
+                descriptor.setInitialized();
             }
         }
-        typeParameterDescriptor.setInitialized();
-    }
-
-    public void initializeTypeParameters(
-            @NotNull List<TypeParameterDescriptorInitialization> typeParametersInitialization,
-            @NotNull DeclarationDescriptor typeParametersOwner
-    ) {
-        List<TypeParameterDescriptor> prevTypeParameters = Lists.newArrayList();
-
-        List<TypeParameterDescriptor> typeParameters = Lists.newArrayList();
-        for (TypeParameterDescriptorInitialization typeParameterDescriptor : typeParametersInitialization) {
-            typeParameters.add(typeParameterDescriptor.descriptor);
-        }
-
-        for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) {
-            prevTypeParameters.add(psiTypeParameter.descriptor);
-
-            initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner));
-        }
-    }
-
-    @NotNull
-    public List<TypeParameterDescriptor> resolveTypeParameters(
-            @NotNull DeclarationDescriptor owner,
-            @NotNull Collection<JavaTypeParameter> typeParameters
-    ) {
-        List<TypeParameterDescriptorInitialization> initializations = makeUninitializedTypeParameters(owner, typeParameters);
-
-        initializeTypeParameters(initializations, owner);
-
-        List<TypeParameterDescriptor> result = Lists.newArrayListWithCapacity(initializations.size());
-
-        for (TypeParameterDescriptorInitialization initialization : initializations) {
-            result.add(initialization.descriptor);
-        }
-
-        return result;
     }
 }