Move and rename JDR.ValueParameterDescriptors

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("<java_root>");
 
     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<ValueParameterDescriptor> descriptors;
-
-        public ValueParameterDescriptors(@Nullable JetType receiverType, @NotNull List<ValueParameterDescriptor> descriptors) {
-            this.receiverType = receiverType;
-            this.descriptors = descriptors;
-        }
-
-        @Nullable
-        public JetType getReceiverType() {
-            return receiverType;
-        }
-
-        @NotNull
-        public List<ValueParameterDescriptor> getDescriptors() {
-            return descriptors;
-        }
-    }
-
     @NotNull
     public Set<FunctionDescriptor> resolveFunctionGroupForClass(@NotNull NamedMembers members, @NotNull ClassOrNamespaceDescriptor owner) {
         return functionResolver.resolveFunctionGroupForClass(members, owner);

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<TypeParameterDescriptor> 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<TypeParameterDescriptor> 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<TypeParameterDescriptor> 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) {
+    private void computeValueParameters(JavaValueParameterResolver.ValueParameters valueParameters) {
-        List<ValueParameterDescriptor> parameterDescriptors = valueParameterDescriptors.getDescriptors();
+        List<ValueParameterDescriptor> 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<TypeParameterDescriptor> typeParameters) {

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<TypeParameterDescriptor> modifiedTypeParameters;
-    private final JavaDescriptorResolver.ValueParameterDescriptors modifiedValueParameters;
+    private final JavaValueParameterResolver.ValueParameters modifiedValueParameters;
     private final JetType modifiedReturnType;
 
     private final List<String> 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<TypeParameterDescriptor> 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(
+    private JavaValueParameterResolver.ValueParameters modifyValueParametersAccordingToSuperMethods(
-            @NotNull JavaDescriptorResolver.ValueParameterDescriptors parameters // descriptors built by parameters resolver
+            @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<FunctionDescriptor> getSuperFunctionsForMethod(

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<TypeParameterDescriptor> 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.<TypeParameterDescriptor>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,
+        constructorDescriptor.initialize(typeParameters, valueParameters.getDescriptors(), constructor.getVisibility(), isStaticClass);
-                                         valueParameterDescriptors.getDescriptors(),
+
-                                         constructor.getVisibility(),
-                                         isStaticClass);
         trace.record(BindingContext.CONSTRUCTOR, constructor.getPsi(), constructorDescriptor);
         return constructorDescriptor;
     }

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
+        JavaValueParameterResolver.ValueParameters valueParameters = valueParameterResolver
-                .resolveParameterDescriptors(functionDescriptorImpl, method, typeVariableResolver);
+                .resolveValueParameters(functionDescriptorImpl, method, typeVariableResolver);
         JetType returnType = makeReturnType(returnJavaType, method, typeVariableResolver);
 
         List<String> signatureErrors = Lists.newArrayList();
@@ -141,11 +140,11 @@ public final class JavaFunctionResolver {
         List<FunctionDescriptor> 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(),

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);
+    }
+
+    public static class ValueParameters {
+        private final JetType receiverType;
+        private final List<ValueParameterDescriptor> descriptors;
+
+        public ValueParameters(@Nullable JetType receiverType, @NotNull List<ValueParameterDescriptor> descriptors) {
+            this.receiverType = receiverType;
+            this.descriptors = descriptors;
+        }
+
+        @Nullable
+        public JetType getReceiverType() {
+            return receiverType;
+        }
+
+        @NotNull
+        public List<ValueParameterDescriptor> getDescriptors() {
+            return descriptors;
+        }
     }
 }