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;
+    public Initializer resolveTypeParameters(
-        private final JavaTypeParameter javaTypeParameter;
+            @NotNull DeclarationDescriptor ownerDescriptor,
-
+            @NotNull JavaTypeParameterListOwner typeParameterListOwner
-        private TypeParameterDescriptorInitialization(
-                @NotNull TypeParameterDescriptorImpl descriptor,
-                @NotNull JavaTypeParameter javaTypeParameter
     ) {
-            this.descriptor = descriptor;
+        Initializer result = new Initializer(ownerDescriptor);
-            this.javaTypeParameter = javaTypeParameter;
+        for (JavaTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) {
-        }
+            result.addTypeParameter(typeParameter);
-
-        @NotNull
-        public TypeParameterDescriptorImpl getDescriptor() {
-            return descriptor;
-        }
-    }
-
-    @NotNull
-    public static List<TypeParameterDescriptorInitialization> makeUninitializedTypeParameters(
-            @NotNull DeclarationDescriptor container,
-            @NotNull Collection<JavaTypeParameter> typeParameters
-    ) {
-        List<TypeParameterDescriptorInitialization> result = Lists.newArrayList();
-        for (JavaTypeParameter typeParameter : typeParameters) {
-            result.add(makeUninitializedTypeParameter(container, 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(
+        private Initializer(@NotNull DeclarationDescriptor owner) {
-                containingDeclaration,
+            this.owner = owner;
+        }
+
+        private void addTypeParameter(@NotNull JavaTypeParameter typeParameter) {
+            TypeParameterDescriptorImpl descriptor = TypeParameterDescriptorImpl.createForFurtherModification(
+                    owner,
                     Collections.<AnnotationDescriptor>emptyList(), // TODO
                     false,
                     Variance.INVARIANT,
                     typeParameter.getName(),
                     typeParameter.getIndex()
             );
-        return new TypeParameterDescriptorInitialization(typeParameterDescriptor, typeParameter);
-    }
 
-    private void initializeTypeParameter(
+            descriptors.add(descriptor);
-            @NotNull TypeParameterDescriptorInitialization initialization,
+            javaTypeParameters.add(typeParameter);
-            @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) {
-                JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver);
-                typeParameterDescriptor.addUpperBound(transformedType);
-            }
-        }
-        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(
+        public List<TypeParameterDescriptor> getDescriptors() {
-            @NotNull DeclarationDescriptor owner,
+            return descriptors;
-            @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;
+        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();
+            }
+        }
     }
 }