From a1f3a56c25427596862da4499d2529e12d076814 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 1 Aug 2013 20:16:06 +0400 Subject: [PATCH] Refactor TypeVariableResolver Delete 'context' field which was used only for debugging --- .../java/resolver/JavaClassResolver.java | 5 +- .../resolver/JavaConstructorResolver.java | 13 ++-- .../java/resolver/JavaFunctionResolver.java | 15 +++-- .../java/resolver/JavaPropertyResolver.java | 21 ++---- .../java/resolver/JavaSignatureResolver.java | 64 ++++++------------- .../java/resolver/JavaSupertypeResolver.java | 3 +- .../java/resolver/JavaTypeTransformer.java | 2 +- .../java/resolver/TypeVariableResolver.java | 21 +++--- 8 files changed, 56 insertions(+), 88 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 6ce6ec408ee..8e2fc75d5de 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 @@ -301,7 +301,7 @@ public final class JavaClassResolver { classDescriptor.setName(javaClass.getName()); List typeParameterDescriptorInitializations - = JavaSignatureResolver.createUninitializedClassTypeParameters(javaClass, classDescriptor); + = JavaSignatureResolver.makeUninitializedTypeParameters(classDescriptor, javaClass.getTypeParameters()); classDescriptor.setTypeParameterDescriptors(getTypeParametersDescriptors(typeParameterDescriptorInitializations)); List supertypes = Lists.newArrayList(); @@ -314,8 +314,7 @@ public final class JavaClassResolver { classDescriptor.setScopeForMemberLookup(scope); classDescriptor.setScopeForConstructorResolve(scope); - signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor, - "class " + javaClass.getFqName()); + signatureResolver.initializeTypeParameters(typeParameterDescriptorInitializations, classDescriptor); // TODO: ugly hack: tests crash if initializeTypeParameters called with class containing proper supertypes List classTypeParameters = classDescriptor.getTypeConstructor().getParameters(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java index 7b76d399929..9ebe3093c00 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaConstructorResolver.java @@ -84,7 +84,7 @@ public final class JavaConstructorResolver { } else { for (JavaMethod constructor : constructors) { - ConstructorDescriptor descriptor = resolveConstructor(javaClass, constructor, containingClass); + ConstructorDescriptor descriptor = resolveConstructor(constructor, containingClass, javaClass.isStatic()); result.add(descriptor); ContainerUtil.addIfNotNull(result, resolveSamAdapter(descriptor)); } @@ -117,8 +117,7 @@ public final class JavaConstructorResolver { List valueParameters; if (isAnnotation) { - TypeVariableResolver typeVariableResolver = - new TypeVariableResolver(typeParameters, containingClass, "class " + javaClass.getFqName()); + TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, containingClass); valueParameters = resolveAnnotationParameters(javaClass, constructorDescriptor, typeVariableResolver); } else { @@ -183,9 +182,9 @@ public final class JavaConstructorResolver { @NotNull private ConstructorDescriptor resolveConstructor( - @NotNull JavaClass javaClass, @NotNull JavaMethod constructor, - @NotNull ClassDescriptor classDescriptor + @NotNull ClassDescriptor classDescriptor, + boolean isStaticClass ) { ConstructorDescriptor alreadyResolved = trace.get(BindingContext.CONSTRUCTOR, constructor.getPsi()); if (alreadyResolved != null) { @@ -201,7 +200,7 @@ public final class JavaConstructorResolver { JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors( constructorDescriptor, constructor, - new TypeVariableResolver(typeParameters, classDescriptor, "constructor of class " + javaClass.getFqName()) + new TypeVariableResolver(typeParameters, classDescriptor) ); if (valueParameterDescriptors.getReceiverType() != null) { @@ -222,7 +221,7 @@ public final class JavaConstructorResolver { constructorDescriptor.initialize(typeParameters, valueParameterDescriptors.getDescriptors(), constructor.getVisibility(), - javaClass.isStatic()); + isStaticClass); trace.record(BindingContext.CONSTRUCTOR, constructor.getPsi(), constructorDescriptor); return constructorDescriptor; } 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 e864bfbcc54..5075f82cccf 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 @@ -28,7 +28,10 @@ import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.descriptors.impl.NamespaceDescriptorParent; import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; import org.jetbrains.jet.lang.resolve.*; -import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; +import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; +import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesPropagationData; @@ -123,14 +126,14 @@ public final class JavaFunctionResolver { CallableMemberDescriptor.Kind.DECLARATION ); - List methodTypeParameters = signatureResolver.resolveMethodTypeParameters(method, functionDescriptorImpl); + List methodTypeParameters = + signatureResolver.resolveTypeParameters(functionDescriptorImpl, method.getTypeParameters()); - TypeVariableResolver methodTypeVariableResolver = new TypeVariableResolver( - methodTypeParameters, functionDescriptorImpl, "method " + method.getName() + " in class " + method.getContainingClass()); + TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl); JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = parameterResolver - .resolveParameterDescriptors(functionDescriptorImpl, method, methodTypeVariableResolver); - JetType returnType = makeReturnType(returnJavaType, method, methodTypeVariableResolver); + .resolveParameterDescriptors(functionDescriptorImpl, method, typeVariableResolver); + JetType returnType = makeReturnType(returnJavaType, method, typeVariableResolver); List signatureErrors = Lists.newArrayList(); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java index 90400951fd1..2325c1d68f6 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaPropertyResolver.java @@ -77,8 +77,7 @@ public final class JavaPropertyResolver { if (fields.size() == 1) { JavaField field = fields.iterator().next(); if (DescriptorResolverUtils.isCorrectOwnerForEnumMember(ownerDescriptor, field)) { - propertiesFromCurrent.add(resolveProperty(ownerDescriptor, propertyName, - "class or namespace " + DescriptorUtils.getFQName(ownerDescriptor), field)); + propertiesFromCurrent.add(resolveProperty(ownerDescriptor, propertyName, field)); } } @@ -124,23 +123,16 @@ public final class JavaPropertyResolver { } @NotNull - private PropertyDescriptor resolveProperty( - @NotNull ClassOrNamespaceDescriptor owner, - @NotNull Name propertyName, - @NotNull String context, - @NotNull JavaField field - ) { + private PropertyDescriptor resolveProperty(@NotNull ClassOrNamespaceDescriptor owner, @NotNull Name name, @NotNull JavaField field) { boolean isVar = !field.isFinal(); - PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, propertyName, field, isVar); - + PropertyDescriptorImpl propertyDescriptor = createPropertyDescriptor(owner, name, field, isVar); propertyDescriptor.initialize(null, null); - TypeVariableResolver typeVariableResolverForPropertyInternals = - new TypeVariableResolver(Collections.emptyList(), propertyDescriptor, - "property " + propertyName + " in " + context); + TypeVariableResolver typeVariableResolver = + new TypeVariableResolver(Collections.emptyList(), propertyDescriptor); - JetType propertyType = getPropertyType(field, typeVariableResolverForPropertyInternals); + JetType propertyType = getPropertyType(field, typeVariableResolver); propertyType = getAlternativeSignatureData(isVar, field, propertyDescriptor, propertyType); @@ -150,6 +142,7 @@ public final class JavaPropertyResolver { DescriptorUtils.getExpectedThisObjectIfNeeded(owner), (JetType) null ); + trace.record(BindingContext.VARIABLE, field.getPsi(), propertyDescriptor); trace.record(JavaBindingContext.IS_DECLARED_IN_JAVA, propertyDescriptor); 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 1941c8e0f18..79bf63545ac 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 @@ -18,15 +18,12 @@ 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.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.resolve.java.TypeUsage; -import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.java.structure.JavaClassifierType; -import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.java.structure.JavaTypeParameter; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.Variance; @@ -66,7 +63,7 @@ public final class JavaSignatureResolver { } @NotNull - private static List makeUninitializedTypeParameters( + public static List makeUninitializedTypeParameters( @NotNull DeclarationDescriptor container, @NotNull Collection typeParameters ) { @@ -94,17 +91,17 @@ public final class JavaSignatureResolver { } private void initializeTypeParameter( - TypeParameterDescriptorInitialization typeParameter, - TypeVariableResolver typeVariableByPsiResolver + @NotNull TypeParameterDescriptorInitialization initialization, + @NotNull TypeVariableResolver typeVariableResolver ) { - TypeParameterDescriptorImpl typeParameterDescriptor = typeParameter.descriptor; - Collection upperBounds = typeParameter.javaTypeParameter.getUpperBounds(); + TypeParameterDescriptorImpl typeParameterDescriptor = initialization.descriptor; + Collection 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, typeVariableByPsiResolver); + JetType transformedType = typeTransformer.transformToType(upperBound, TypeUsage.UPPER_BOUND, typeVariableResolver); typeParameterDescriptor.addUpperBound(transformedType); } } @@ -112,9 +109,8 @@ public final class JavaSignatureResolver { } public void initializeTypeParameters( - List typeParametersInitialization, - @NotNull DeclarationDescriptor typeParametersOwner, - @NotNull String context + @NotNull List typeParametersInitialization, + @NotNull DeclarationDescriptor typeParametersOwner ) { List prevTypeParameters = Lists.newArrayList(); @@ -126,43 +122,25 @@ public final class JavaSignatureResolver { for (TypeParameterDescriptorInitialization psiTypeParameter : typeParametersInitialization) { prevTypeParameters.add(psiTypeParameter.descriptor); - initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner, context)); + initializeTypeParameter(psiTypeParameter, new TypeVariableResolver(typeParameters, typeParametersOwner)); } } - @NotNull - public static List createUninitializedClassTypeParameters( - JavaClass javaClass, ClassDescriptor classDescriptor + public List resolveTypeParameters( + @NotNull DeclarationDescriptor owner, + @NotNull Collection typeParameters ) { - List result = Lists.newArrayList(); - for (JavaTypeParameter typeParameter : javaClass.getTypeParameters()) { - TypeParameterDescriptorInitialization typeParameterDescriptor = makeUninitializedTypeParameter(classDescriptor, typeParameter); - result.add(typeParameterDescriptor); + List initializations = makeUninitializedTypeParameters(owner, typeParameters); + + initializeTypeParameters(initializations, owner); + + List result = Lists.newArrayListWithCapacity(initializations.size()); + + for (TypeParameterDescriptorInitialization initialization : initializations) { + result.add(initialization.descriptor); } + return result; } - - - @NotNull - public List resolveMethodTypeParameters( - @NotNull JavaMethod method, - @NotNull DeclarationDescriptor functionDescriptor - ) { - List typeParametersIntialization = - makeUninitializedTypeParameters(functionDescriptor, method.getTypeParameters()); - - JavaClass containingClass = method.getContainingClass(); - assert containingClass != null; - initializeTypeParameters(typeParametersIntialization, functionDescriptor, - "method " + method.getName() + " in class " + containingClass.getFqName()); - - List typeParameters = Lists.newArrayListWithCapacity(typeParametersIntialization.size()); - - for (TypeParameterDescriptorInitialization tpdi : typeParametersIntialization) { - typeParameters.add(tpdi.descriptor); - } - - return typeParameters; - } } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java index 186cf1b0b70..dce57df46f9 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaSupertypeResolver.java @@ -69,8 +69,7 @@ public final class JavaSupertypeResolver { @NotNull JavaClass javaClass, @NotNull List typeParameters ) { - TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, classDescriptor, - "class " + javaClass.getFqName()); + TypeVariableResolver typeVariableResolver = new TypeVariableResolver(typeParameters, classDescriptor); List result = transformSupertypeList(javaClass.getSupertypes(), typeVariableResolver); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java index d2a25bbe4ab..e21507d0896 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaTypeTransformer.java @@ -143,7 +143,7 @@ public class JavaTypeTransformer { return TypeUtils.intersect(JetTypeChecker.INSTANCE, supertypesJet); } - TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName().asString()); + TypeParameterDescriptor typeParameterDescriptor = typeVariableResolver.getTypeVariable(typeParameter.getName()); // In Java: ArrayList // In Kotlin: ArrayList, not ArrayList diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java index 691ee75841e..8b7d34d0eb3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/TypeVariableResolver.java @@ -22,25 +22,22 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; +import org.jetbrains.jet.lang.resolve.name.Name; import java.util.List; /* package */ class TypeVariableResolver { @NotNull - protected final List typeParameters; + private final List typeParameters; @NotNull - protected final DeclarationDescriptor owner; - @NotNull - protected final String context; + private final DeclarationDescriptor owner; public TypeVariableResolver( @NotNull List typeParameters, - @NotNull DeclarationDescriptor owner, - @NotNull String context + @NotNull DeclarationDescriptor owner ) { this.typeParameters = typeParameters; this.owner = owner; - this.context = context; assert ContainerUtil.and(typeParameters, new Condition() { @Override @@ -51,18 +48,18 @@ import java.util.List; } @NotNull - public TypeParameterDescriptor getTypeVariable(@NotNull String name) { + public TypeParameterDescriptor getTypeVariable(@NotNull Name name) { return getTypeVariable(name, typeParameters, owner); } @NotNull - private TypeParameterDescriptor getTypeVariable( - @NotNull String name, + private static TypeParameterDescriptor getTypeVariable( + @NotNull Name name, @NotNull List typeParameters, @NotNull DeclarationDescriptor owner ) { for (TypeParameterDescriptor typeParameter : typeParameters) { - if (typeParameter.getName().asString().equals(name)) { + if (typeParameter.getName().equals(name)) { return typeParameter; } } @@ -72,6 +69,6 @@ import java.util.List; return getTypeVariable(name, ((ClassDescriptor) container).getTypeConstructor().getParameters(), container); } - throw new IllegalStateException("Type parameter not found by name '" + name + "' in " + context); + throw new IllegalStateException("Type parameter not found by name: " + name); } }