diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 8e2fc75d5de..4c0a6391f48 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/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 typeParameterDescriptorInitializations - = JavaSignatureResolver.makeUninitializedTypeParameters(classDescriptor, javaClass.getTypeParameters()); + JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(classDescriptor, javaClass); + classDescriptor.setTypeParameterDescriptors(typeParameterInitializer.getDescriptors()); - classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations)); List 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 classTypeParameters = classDescriptor.getTypeConstructor().getParameters(); @@ -400,17 +399,6 @@ public final class JavaClassResolver { } } - @NotNull - private static List getTypeParametersDescriptors( - @NotNull List typeParameterDescriptorInitializations - ) { - List 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; diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java index 5075f82cccf..8e14ff8128f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaFunctionResolver.java +++ b/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 methodTypeParameters = - signatureResolver.resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()); + JavaSignatureResolver.Initializer typeParameterInitializer = signatureResolver.resolveTypeParameters(functionDescriptorImpl, method); + typeParameterInitializer.initialize(); + List methodTypeParameters = typeParameterInitializer.getDescriptors(); TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java index 79bf63545ac..b5ae09363f5 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSignatureResolver.java +++ b/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.Collections; -import java.util.List; +import java.util.*; 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 makeUninitializedTypeParameters( - @NotNull DeclarationDescriptor container, - @NotNull Collection typeParameters + public Initializer resolveTypeParameters( + @NotNull DeclarationDescriptor ownerDescriptor, + @NotNull JavaTypeParameterListOwner typeParameterListOwner ) { - List result = Lists.newArrayList(); - for (JavaTypeParameter typeParameter : typeParameters) { - result.add(makeUninitializedTypeParameter(container, typeParameter)); + Initializer result = new Initializer(ownerDescriptor); + for (JavaTypeParameter typeParameter : typeParameterListOwner.getTypeParameters()) { + result.addTypeParameter(typeParameter); } return result; } - @NotNull - private static TypeParameterDescriptorInitialization makeUninitializedTypeParameter( - @NotNull DeclarationDescriptor containingDeclaration, - @NotNull JavaTypeParameter typeParameter - ) { - TypeParameterDescriptorImpl typeParameterDescriptor = TypeParameterDescriptorImpl.createForFurtherModification( - containingDeclaration, - Collections.emptyList(), // TODO - false, - Variance.INVARIANT, - typeParameter.getName(), - typeParameter.getIndex() - ); - return new TypeParameterDescriptorInitialization(typeParameterDescriptor, typeParameter); - } + public class Initializer { + private final DeclarationDescriptor owner; + private final List descriptors = new ArrayList(); + private final List javaTypeParameters = new ArrayList(); - private void initializeTypeParameter( - @NotNull TypeParameterDescriptorInitialization initialization, - @NotNull TypeVariableResolver typeVariableResolver - ) { - TypeParameterDescriptorImpl typeParameterDescriptor = initialization.descriptor; - Collection upperBounds = initialization.javaTypeParameter.getUpperBounds(); - if (upperBounds.isEmpty()) { - typeParameterDescriptor.addUpperBound(KotlinBuiltIns.getInstance().getNullableAnyType()); + private Initializer(@NotNull DeclarationDescriptor owner) { + this.owner = owner; } - else { - for (JavaClassifierType upperBound : upperBounds) { - JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver); - typeParameterDescriptor.addUpperBound(transformedType); + + private void addTypeParameter(@NotNull JavaTypeParameter typeParameter) { + TypeParameterDescriptorImpl descriptor = TypeParameterDescriptorImpl.createForFurtherModification( + owner, + Collections.emptyList(), // TODO + false, + Variance.INVARIANT, + typeParameter.getName(), + typeParameter.getIndex() + ); + + descriptors.add(descriptor); + javaTypeParameters.add(typeParameter); + } + + @NotNull + public List getDescriptors() { + return descriptors; + } + + public void initialize() { + TypeVariableResolver typeVariableResolver = new TypeVariableResolver(getDescriptors(), owner); + + Iterator descriptorIterator = descriptors.iterator(); + Iterator typeParameterIterator = javaTypeParameters.iterator(); + + while (descriptorIterator.hasNext()) { + TypeParameterDescriptorImpl descriptor = (TypeParameterDescriptorImpl) descriptorIterator.next(); + Collection 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 typeParametersInitialization, - @NotNull DeclarationDescriptor typeParametersOwner - ) { - List prevTypeParameters = Lists.newArrayList(); - - List 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 resolveTypeParameters( - @NotNull DeclarationDescriptor owner, - @NotNull Collection typeParameters - ) { - List initializations = makeUninitializedTypeParameters(owner, typeParameters); - - initializeTypeParameters(initializations, owner); - - List result = Lists.newArrayListWithCapacity(initializations.size()); - - for (TypeParameterDescriptorInitialization initialization : initializations) { - result.add(initialization.descriptor); - } - - return result; } }