From 944d1fc59eef99e6eeba8bd3a6961eb6f863d84d Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 1 Aug 2013 21:02:17 +0400 Subject: [PATCH] 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 --- .../java/resolver/JavaClassResolver.java | 18 +-- .../java/resolver/JavaFunctionResolver.java | 5 +- .../java/resolver/JavaSignatureResolver.java | 147 +++++++----------- 3 files changed, 59 insertions(+), 111 deletions(-) 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; } }