From f1892372eb183df5d3ac2a34326a398311f9c91a Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 1 Aug 2013 21:50:24 +0400 Subject: [PATCH] Move and rename JDR.ValueParameterDescriptors --- .../resolve/java/JavaDescriptorResolver.java | 25 +-------------- .../AlternativeMethodSignatureData.java | 24 +++++++------- .../SignaturesPropagationData.java | 16 +++++----- .../resolver/JavaConstructorResolver.java | 15 ++++----- .../java/resolver/JavaFunctionResolver.java | 17 +++++----- .../resolver/JavaValueParameterResolver.java | 32 +++++++++++++++---- 6 files changed, 61 insertions(+), 68 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java index fa03758f9c4..2d9b435ab79 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaDescriptorResolver.java @@ -19,24 +19,21 @@ package org.jetbrains.jet.lang.resolve.java; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; import org.jetbrains.jet.lang.resolve.java.resolver.*; +import org.jetbrains.jet.lang.resolve.java.scope.NamedMembers; import org.jetbrains.jet.lang.resolve.java.structure.JavaClass; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.resolve.scopes.JetScope; import org.jetbrains.jet.lang.types.DependencyClassByQualifiedNameResolver; -import org.jetbrains.jet.lang.types.JetType; import javax.inject.Inject; import java.util.Collection; -import java.util.List; import java.util.Set; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.IGNORE_KOTLIN_SOURCES; public class JavaDescriptorResolver implements DependencyClassByQualifiedNameResolver { - public static final Name JAVA_ROOT = Name.special(""); private JavaPropertyResolver propertiesResolver; @@ -100,26 +97,6 @@ public class JavaDescriptorResolver implements DependencyClassByQualifiedNameRes return propertiesResolver.resolveFieldGroup(members, ownerDescriptor); } - public static class ValueParameterDescriptors { - private final JetType receiverType; - private final List descriptors; - - public ValueParameterDescriptors(@Nullable JetType receiverType, @NotNull List descriptors) { - this.receiverType = receiverType; - this.descriptors = descriptors; - } - - @Nullable - public JetType getReceiverType() { - return receiverType; - } - - @NotNull - public List getDescriptors() { - return descriptors; - } - } - @NotNull public Set resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) { return functionResolver.resolveFunctionGroupForClass(members, owner); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java index 72689c4bc99..a218f62177f 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java @@ -26,7 +26,7 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; import org.jetbrains.jet.lang.psi.*; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -46,7 +46,7 @@ import static org.jetbrains.jet.lang.resolve.java.TypeUsage.UPPER_BOUND; public class AlternativeMethodSignatureData extends ElementAlternativeSignatureData { private final JetNamedFunction altFunDeclaration; - private JavaDescriptorResolver.ValueParameterDescriptors altValueParameters; + private JavaValueParameterResolver.ValueParameters altValueParameters; private JetType altReturnType; private List altTypeParameters; @@ -54,7 +54,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD public AlternativeMethodSignatureData( @NotNull JavaMethod method, - @NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors, + @NotNull JavaValueParameterResolver.ValueParameters valueParameters, @Nullable JetType originalReturnType, @NotNull List methodTypeParameters, boolean hasSuperMethods @@ -78,14 +78,14 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD checkEqualFunctionNames(altFunDeclaration, method); computeTypeParameters(methodTypeParameters); - computeValueParameters(valueParameterDescriptors); + computeValueParameters(valueParameters); if (originalReturnType != null) { altReturnType = computeReturnType(originalReturnType, altFunDeclaration.getReturnTypeRef(), originalToAltTypeParameters); } if (hasSuperMethods) { - checkParameterAndReturnTypesForOverridingMethods(valueParameterDescriptors, methodTypeParameters, originalReturnType); + checkParameterAndReturnTypesForOverridingMethods(valueParameters, methodTypeParameters, originalReturnType); } } catch (AlternativeSignatureMismatchException e) { @@ -94,13 +94,13 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD } private void checkParameterAndReturnTypesForOverridingMethods( - @NotNull JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors, + @NotNull JavaValueParameterResolver.ValueParameters valueParameters, @NotNull List methodTypeParameters, @Nullable JetType returnType ) { TypeSubstitutor substitutor = SignaturesUtil.createSubstitutorForTypeParameters(originalToAltTypeParameters); - for (ValueParameterDescriptor parameter : valueParameterDescriptors.getDescriptors()) { + for (ValueParameterDescriptor parameter : valueParameters.getDescriptors()) { int index = parameter.getIndex(); ValueParameterDescriptor altParameter = altValueParameters.getDescriptors().get(index); @@ -141,7 +141,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD } @NotNull - public JavaDescriptorResolver.ValueParameterDescriptors getValueParameters() { + public JavaValueParameterResolver.ValueParameters getValueParameters() { checkForErrors(); return altValueParameters; } @@ -158,8 +158,8 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD return altTypeParameters; } - private void computeValueParameters(JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors) { - List parameterDescriptors = valueParameterDescriptors.getDescriptors(); + private void computeValueParameters(JavaValueParameterResolver.ValueParameters valueParameters) { + List parameterDescriptors = valueParameters.getDescriptors(); if (parameterDescriptors.size() != altFunDeclaration.getValueParameters().size()) { throw new AlternativeSignatureMismatchException("Method signature has %d value parameters, but alternative signature has %d", @@ -207,11 +207,11 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD alternativeVarargElementType)); } - if (valueParameterDescriptors.getReceiverType() != null) { + if (valueParameters.getReceiverType() != null) { throw new UnsupportedOperationException("Alternative annotations for extension functions are not supported yet"); } - altValueParameters = new JavaDescriptorResolver.ValueParameterDescriptors(null, altParamDescriptors); + altValueParameters = new JavaValueParameterResolver.ValueParameters(null, altParamDescriptors); } private void computeTypeParameters(List typeParameters) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java index 1aa5faa5c26..edd1f0d0b3d 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java @@ -36,10 +36,10 @@ import org.jetbrains.jet.lang.resolve.BindingContextUtils; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; -import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetClsMethod; import org.jetbrains.jet.lang.resolve.java.TypeUsage; +import org.jetbrains.jet.lang.resolve.java.jetAsJava.JetClsMethod; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; +import org.jetbrains.jet.lang.resolve.java.resolver.JavaValueParameterResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; @@ -58,7 +58,7 @@ public class SignaturesPropagationData { private static final Logger LOG = Logger.getInstance(SignaturesPropagationData.class); private final List modifiedTypeParameters; - private final JavaDescriptorResolver.ValueParameterDescriptors modifiedValueParameters; + private final JavaValueParameterResolver.ValueParameters modifiedValueParameters; private final JetType modifiedReturnType; private final List signatureErrors = Lists.newArrayList(); @@ -69,7 +69,7 @@ public class SignaturesPropagationData { public SignaturesPropagationData( @NotNull ClassDescriptor containingClass, @NotNull JetType autoReturnType, // type built by JavaTypeTransformer from Java signature and @NotNull annotations - @NotNull JavaDescriptorResolver.ValueParameterDescriptors autoValueParameters, // descriptors built by parameters resolver + @NotNull JavaValueParameterResolver.ValueParameters autoValueParameters, // descriptors built by parameters resolver @NotNull List autoTypeParameters, // descriptors built by signature resolver @NotNull JavaMethod method, @NotNull BindingTrace trace @@ -88,7 +88,7 @@ public class SignaturesPropagationData { return modifiedTypeParameters; } - public JavaDescriptorResolver.ValueParameterDescriptors getModifiedValueParameters() { + public JavaValueParameterResolver.ValueParameters getModifiedValueParameters() { return modifiedValueParameters; } @@ -157,8 +157,8 @@ public class SignaturesPropagationData { return result; } - private JavaDescriptorResolver.ValueParameterDescriptors modifyValueParametersAccordingToSuperMethods( - @NotNull JavaDescriptorResolver.ValueParameterDescriptors parameters // descriptors built by parameters resolver + private JavaValueParameterResolver.ValueParameters modifyValueParametersAccordingToSuperMethods( + @NotNull JavaValueParameterResolver.ValueParameters parameters // descriptors built by parameters resolver ) { assert parameters.getReceiverType() == null : "Parameters before propagation have receiver type," + " but propagation should be disabled for functions compiled from Kotlin in class: " + @@ -205,7 +205,7 @@ public class SignaturesPropagationData { } } - return new JavaDescriptorResolver.ValueParameterDescriptors(receiverType, resultParameters); + return new JavaValueParameterResolver.ValueParameters(receiverType, resultParameters); } private static List getSuperFunctionsForMethod( 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 9ebe3093c00..7421ce3dbf3 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 @@ -28,7 +28,6 @@ import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.DescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaBindingContext; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; import org.jetbrains.jet.lang.resolve.java.kotlinSignature.AlternativeMethodSignatureData; import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; @@ -198,30 +197,28 @@ public final class JavaConstructorResolver { List typeParameters = classDescriptor.getTypeConstructor().getParameters(); - JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver.resolveParameterDescriptors( + JavaValueParameterResolver.ValueParameters valueParameters = valueParameterResolver.resolveValueParameters( constructorDescriptor, constructor, new TypeVariableResolver(typeParameters, classDescriptor) ); - if (valueParameterDescriptors.getReceiverType() != null) { + if (valueParameters.getReceiverType() != null) { throw new IllegalStateException(); } AlternativeMethodSignatureData alternativeMethodSignatureData = - new AlternativeMethodSignatureData(constructor, valueParameterDescriptors, null, + new AlternativeMethodSignatureData(constructor, valueParameters, null, Collections.emptyList(), false); if (alternativeMethodSignatureData.isAnnotated() && !alternativeMethodSignatureData.hasErrors()) { - valueParameterDescriptors = alternativeMethodSignatureData.getValueParameters(); + valueParameters = alternativeMethodSignatureData.getValueParameters(); } else if (alternativeMethodSignatureData.hasErrors()) { trace.record(JavaBindingContext.LOAD_FROM_JAVA_SIGNATURE_ERRORS, constructorDescriptor, Collections.singletonList(alternativeMethodSignatureData.getError())); } - constructorDescriptor.initialize(typeParameters, - valueParameterDescriptors.getDescriptors(), - constructor.getVisibility(), - isStaticClass); + constructorDescriptor.initialize(typeParameters, valueParameters.getDescriptors(), constructor.getVisibility(), 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 b4aae8fd48a..ed93c79067e 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 @@ -30,7 +30,6 @@ import org.jetbrains.jet.lang.descriptors.impl.SimpleFunctionDescriptorImpl; import org.jetbrains.jet.lang.resolve.*; 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; @@ -132,8 +131,8 @@ public final class JavaFunctionResolver { TypeVariableResolver typeVariableResolver = new TypeVariableResolver(methodTypeParameters, functionDescriptorImpl); - JavaDescriptorResolver.ValueParameterDescriptors valueParameterDescriptors = valueParameterResolver - .resolveParameterDescriptors(functionDescriptorImpl, method, typeVariableResolver); + JavaValueParameterResolver.ValueParameters valueParameters = valueParameterResolver + .resolveValueParameters(functionDescriptorImpl, method, typeVariableResolver); JetType returnType = makeReturnType(returnJavaType, method, typeVariableResolver); List signatureErrors = Lists.newArrayList(); @@ -141,11 +140,11 @@ public final class JavaFunctionResolver { List superFunctions; if (ownerDescriptor instanceof ClassDescriptor) { SignaturesPropagationData signaturesPropagationData = new SignaturesPropagationData( - (ClassDescriptor) ownerDescriptor, returnType, valueParameterDescriptors, methodTypeParameters, method, trace); + (ClassDescriptor) ownerDescriptor, returnType, valueParameters, methodTypeParameters, method, trace); superFunctions = signaturesPropagationData.getSuperFunctions(); returnType = signaturesPropagationData.getModifiedReturnType(); - valueParameterDescriptors = signaturesPropagationData.getModifiedValueParameters(); + valueParameters = signaturesPropagationData.getModifiedValueParameters(); methodTypeParameters = signaturesPropagationData.getModifiedTypeParameters(); signatureErrors.addAll(signaturesPropagationData.getSignatureErrors()); @@ -155,10 +154,10 @@ public final class JavaFunctionResolver { } AlternativeMethodSignatureData alternativeMethodSignatureData = - new AlternativeMethodSignatureData(method, valueParameterDescriptors, returnType, methodTypeParameters, + new AlternativeMethodSignatureData(method, valueParameters, returnType, methodTypeParameters, !superFunctions.isEmpty()); if (alternativeMethodSignatureData.isAnnotated() && !alternativeMethodSignatureData.hasErrors()) { - valueParameterDescriptors = alternativeMethodSignatureData.getValueParameters(); + valueParameters = alternativeMethodSignatureData.getValueParameters(); returnType = alternativeMethodSignatureData.getReturnType(); methodTypeParameters = alternativeMethodSignatureData.getTypeParameters(); } @@ -167,10 +166,10 @@ public final class JavaFunctionResolver { } functionDescriptorImpl.initialize( - valueParameterDescriptors.getReceiverType(), + valueParameters.getReceiverType(), DescriptorUtils.getExpectedThisObjectIfNeeded(ownerDescriptor), methodTypeParameters, - valueParameterDescriptors.getDescriptors(), + valueParameters.getDescriptors(), returnType, Modality.convertFromFlags(method.isAbstract(), !method.isFinal()), method.getVisibility(), diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java index 5684c5db109..81df82effa3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaValueParameterResolver.java @@ -17,11 +17,11 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor; import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl; -import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver; import org.jetbrains.jet.lang.resolve.java.TypeUsage; import org.jetbrains.jet.lang.resolve.java.structure.JavaArrayType; import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod; @@ -39,7 +39,7 @@ public final class JavaValueParameterResolver { private JavaTypeTransformer typeTransformer; @NotNull - private ValueParameterDescriptor resolveParameterDescriptor( + private ValueParameterDescriptor resolveValueParameter( @NotNull DeclarationDescriptor containingDeclaration, int i, @NotNull JavaValueParameter parameter, @@ -95,7 +95,7 @@ public final class JavaValueParameterResolver { } @NotNull - public JavaDescriptorResolver.ValueParameterDescriptors resolveParameterDescriptors( + public ValueParameters resolveValueParameters( @NotNull DeclarationDescriptor container, @NotNull JavaMethod method, @NotNull TypeVariableResolver typeVariableResolver @@ -107,10 +107,30 @@ public final class JavaValueParameterResolver { JavaValueParameter parameter = iterator.next(); boolean isVararg = method.isVararg() && !iterator.hasNext(); - ValueParameterDescriptor descriptor = resolveParameterDescriptor(container, index, parameter, typeVariableResolver, isVararg); + ValueParameterDescriptor descriptor = resolveValueParameter(container, index, parameter, typeVariableResolver, isVararg); result.add(descriptor); index++; } - return new JavaDescriptorResolver.ValueParameterDescriptors(null, result); + return new ValueParameters(null, result); } -} \ No newline at end of file + + public static class ValueParameters { + private final JetType receiverType; + private final List descriptors; + + public ValueParameters(@Nullable JetType receiverType, @NotNull List descriptors) { + this.receiverType = receiverType; + this.descriptors = descriptors; + } + + @Nullable + public JetType getReceiverType() { + return receiverType; + } + + @NotNull + public List getDescriptors() { + return descriptors; + } + } +}