Move utilities out of 'core' to where they are used

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaResolverPsiUtils.java

@@ -18,8 +18,19 @@ package org.jetbrains.jet.lang.resolve.java;
 
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.jet.lang.resolve.java.structure.JavaClass;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.descriptors.DeclarationDescriptor;
+import org.jetbrains.jet.lang.descriptors.SourceElement;
+import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor;
+import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
+import org.jetbrains.jet.lang.resolve.java.structure.*;
 import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaClassImpl;
+import org.jetbrains.jet.lang.types.TypeConstructor;
+import org.jetbrains.jet.lang.types.TypeProjection;
+import org.jetbrains.jet.lang.types.TypeProjectionImpl;
+import org.jetbrains.jet.lang.types.TypeSubstitutor;
+
+import java.util.*;
 
 import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_CLASS;
 import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_PACKAGE;
@@ -41,4 +52,114 @@ public class JavaResolverPsiUtils {
     public static boolean isCompiledKotlinClassOrPackageClass(@NotNull PsiClass psiClass) {
         return isCompiledKotlinClass(psiClass) || isCompiledKotlinPackageClass(psiClass);
     }
+
+    /**
+     * @see com.intellij.psi.util.TypeConversionUtil#erasure(com.intellij.psi.PsiType)
+     */
+    @Nullable
+    public static JavaType erasure(@NotNull JavaType type) {
+        return erasure(type, JavaTypeSubstitutor.EMPTY);
+    }
+
+    /**
+     * @see com.intellij.psi.util.TypeConversionUtil#erasure(com.intellij.psi.PsiType, com.intellij.psi.PsiSubstitutor)
+     */
+    @Nullable
+    public static JavaType erasure(@NotNull JavaType type, @NotNull JavaTypeSubstitutor substitutor) {
+        if (type instanceof JavaClassifierType) {
+            JavaClassifier classifier = ((JavaClassifierType) type).getClassifier();
+            if (classifier instanceof JavaClass) {
+                return ((JavaClass) classifier).getDefaultType();
+            }
+            else if (classifier instanceof JavaTypeParameter) {
+                JavaTypeParameter typeParameter = (JavaTypeParameter) classifier;
+                return typeParameterErasure(typeParameter, new HashSet<JavaTypeParameter>(), substitutor);
+            }
+            else {
+                return null;
+            }
+        }
+        else if (type instanceof JavaPrimitiveType) {
+            return type;
+        }
+        else if (type instanceof JavaArrayType) {
+            JavaType erasure = erasure(((JavaArrayType) type).getComponentType(), substitutor);
+            return erasure == null ? null : erasure.createArrayType();
+        }
+        else if (type instanceof JavaWildcardType) {
+            JavaWildcardType wildcardType = (JavaWildcardType) type;
+            JavaType bound = wildcardType.getBound();
+            if (bound != null && wildcardType.isExtends()) {
+                return erasure(bound, substitutor);
+            }
+            return wildcardType.getTypeProvider().createJavaLangObjectType();
+        }
+        else {
+            throw new IllegalStateException("Unsupported type: " + type);
+        }
+    }
+
+    /**
+     * @see com.intellij.psi.util.TypeConversionUtil#typeParameterErasure(com.intellij.psi.PsiTypeParameter)
+     */
+    @Nullable
+    private static JavaType typeParameterErasure(
+            @NotNull JavaTypeParameter typeParameter,
+            @NotNull HashSet<JavaTypeParameter> visited,
+            @NotNull JavaTypeSubstitutor substitutor
+    ) {
+        Collection<JavaClassifierType> upperBounds = typeParameter.getUpperBounds();
+        if (!upperBounds.isEmpty()) {
+            JavaClassifier classifier = upperBounds.iterator().next().getClassifier();
+            if (classifier instanceof JavaTypeParameter && !visited.contains(classifier)) {
+                JavaTypeParameter typeParameterBound = (JavaTypeParameter) classifier;
+                visited.add(typeParameterBound);
+                JavaType substitutedType = substitutor.substitute(typeParameterBound);
+                if (substitutedType != null) {
+                    return erasure(substitutedType);
+                }
+                return typeParameterErasure(typeParameterBound, visited, substitutor);
+            }
+            else if (classifier instanceof JavaClass) {
+                return ((JavaClass) classifier).getDefaultType();
+            }
+        }
+        return typeParameter.getTypeProvider().createJavaLangObjectType();
+    }
+
+    @NotNull
+    public static Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> recreateTypeParametersAndReturnMapping(
+            @NotNull List<TypeParameterDescriptor> originalParameters,
+            @Nullable DeclarationDescriptor newOwner
+    ) {
+        // LinkedHashMap to save the order of type parameters
+        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> result =
+                new LinkedHashMap<TypeParameterDescriptor, TypeParameterDescriptorImpl>();
+        for (TypeParameterDescriptor typeParameter : originalParameters) {
+            result.put(typeParameter,
+                       TypeParameterDescriptorImpl.createForFurtherModification(
+                               newOwner == null ? typeParameter.getContainingDeclaration() : newOwner,
+                               typeParameter.getAnnotations(),
+                               typeParameter.isReified(),
+                               typeParameter.getVariance(),
+                               typeParameter.getName(),
+                               typeParameter.getIndex(),
+                               SourceElement.NO_SOURCE
+                       )
+            );
+        }
+        return result;
+    }
+
+    @NotNull
+    public static TypeSubstitutor createSubstitutorForTypeParameters(
+            @NotNull Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters
+    ) {
+        Map<TypeConstructor, TypeProjection> typeSubstitutionContext = new HashMap<TypeConstructor, TypeProjection>();
+        for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameter : originalToAltTypeParameters.entrySet()) {
+            typeSubstitutionContext.put(originalToAltTypeParameter.getKey().getTypeConstructor(),
+                                        new TypeProjectionImpl(originalToAltTypeParameter.getValue().getDefaultType()));
+        }
+        return TypeSubstitutor.create(typeSubstitutionContext);
+    }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/AlternativeMethodSignatureData.java

@@ -29,7 +29,7 @@ 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.JavaPackage;
-import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.JavaResolverPsiUtils;
 import org.jetbrains.jet.lang.resolve.java.resolver.ExternalAnnotationResolver;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMember;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -80,7 +80,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
         setAnnotated(true);
         altFunDeclaration = JetPsiFactory(project).createFunction(signature);
 
-        originalToAltTypeParameters = DescriptorResolverUtils.recreateTypeParametersAndReturnMapping(methodTypeParameters, null);
+        originalToAltTypeParameters = JavaResolverPsiUtils.recreateTypeParametersAndReturnMapping(methodTypeParameters, null);
 
         try {
             checkForSyntaxErrors(altFunDeclaration);
@@ -121,7 +121,7 @@ public class AlternativeMethodSignatureData extends ElementAlternativeSignatureD
             @Nullable JetType returnType
     ) {
         if (JavaPackage.getPLATFORM_TYPES()) return;
-        TypeSubstitutor substitutor = DescriptorResolverUtils.createSubstitutorForTypeParameters(originalToAltTypeParameters);
+        TypeSubstitutor substitutor = JavaResolverPsiUtils.createSubstitutorForTypeParameters(originalToAltTypeParameters);
 
         for (ValueParameterDescriptor parameter : valueParameters) {
             int index = parameter.getIndex();

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesPropagationData.java

@@ -31,11 +31,11 @@ import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.DescriptorUtils;
 import org.jetbrains.jet.lang.resolve.java.JavaPackage;
+import org.jetbrains.jet.lang.resolve.java.JavaResolverPsiUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.JavaMethodDescriptor;
 import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmMethodSignature;
 import org.jetbrains.jet.lang.resolve.java.jvmSignature.JvmSignaturePackage;
 import org.jetbrains.jet.lang.resolve.java.jvmSignature.KotlinToJvmSignatureMapper;
-import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils;
 import org.jetbrains.jet.lang.resolve.java.resolver.TypeUsage;
 import org.jetbrains.jet.lang.resolve.java.structure.JavaMethod;
 import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
@@ -84,7 +84,7 @@ public class SignaturesPropagationData {
 
         superFunctions = getSuperFunctionsForMethod(method, autoMethodDescriptor, containingClass);
 
-        autoTypeParameterToModified = DescriptorResolverUtils.recreateTypeParametersAndReturnMapping(autoTypeParameters, null);
+        autoTypeParameterToModified = JavaResolverPsiUtils.recreateTypeParametersAndReturnMapping(autoTypeParameters, null);
 
         modifiedTypeParameters = modifyTypeParametersAccordingToSuperMethods(autoTypeParameters);
         modifiedReturnType = modifyReturnTypeAccordingToSuperMethods(autoReturnType);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java

@@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.descriptors.annotations.Annotations;
 import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
 import org.jetbrains.jet.lang.descriptors.impl.ValueParameterDescriptorImpl;
 import org.jetbrains.jet.lang.resolve.java.JavaPackage;
+import org.jetbrains.jet.lang.resolve.java.JavaResolverPsiUtils;
 import org.jetbrains.jet.lang.resolve.java.descriptor.*;
 import org.jetbrains.jet.lang.resolve.java.lazy.types.LazyJavaTypeResolver;
 import org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils;
@@ -273,8 +274,8 @@ public class SingleAbstractMethodUtils {
             @Nullable DeclarationDescriptor newOwner
     ) {
         Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> traitToFunTypeParameters =
-                DescriptorResolverUtils.recreateTypeParametersAndReturnMapping(originalParameters, newOwner);
+                JavaResolverPsiUtils.recreateTypeParametersAndReturnMapping(originalParameters, newOwner);
-        TypeSubstitutor typeParametersSubstitutor = DescriptorResolverUtils.createSubstitutorForTypeParameters(traitToFunTypeParameters);
+        TypeSubstitutor typeParametersSubstitutor = JavaResolverPsiUtils.createSubstitutorForTypeParameters(traitToFunTypeParameters);
         for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> mapEntry : traitToFunTypeParameters.entrySet()) {
             TypeParameterDescriptor traitTypeParameter = mapEntry.getKey();
             TypeParameterDescriptorImpl funTypeParameter = mapEntry.getValue();
@@ -404,8 +405,8 @@ public class SingleAbstractMethodUtils {
                 JavaValueParameter param2 = it2.next();
                 if (param1.isVararg() != param2.isVararg()) return false;
 
-                JavaType type1 = DescriptorResolverUtils.erasure(substitutor1.substitute(param1.getType()), substitutor1);
+                JavaType type1 = JavaResolverPsiUtils.erasure(substitutor1.substitute(param1.getType()), substitutor1);
-                JavaType type2 = DescriptorResolverUtils.erasure(substitutor2.substitute(param2.getType()), substitutor2);
+                JavaType type2 = JavaResolverPsiUtils.erasure(substitutor2.substitute(param2.getType()), substitutor2);
                 if (!(type1 == null ? type2 == null : type1.equals(type2))) return false;
             }
 

core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java

@@ -20,16 +20,14 @@ import kotlin.Function1;
 import kotlin.Unit;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import org.jetbrains.jet.lang.descriptors.*;
+import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor;
-import org.jetbrains.jet.lang.descriptors.impl.TypeParameterDescriptorImpl;
+import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
+import org.jetbrains.jet.lang.descriptors.ConstructorDescriptor;
+import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
 import org.jetbrains.jet.lang.resolve.OverridingUtil;
 import org.jetbrains.jet.lang.resolve.java.structure.*;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
-import org.jetbrains.jet.lang.types.TypeConstructor;
-import org.jetbrains.jet.lang.types.TypeProjection;
-import org.jetbrains.jet.lang.types.TypeProjectionImpl;
-import org.jetbrains.jet.lang.types.TypeSubstitutor;
 
 import java.util.*;
 
@@ -132,114 +130,4 @@ public final class DescriptorResolverUtils {
 
         return result;
     }
-
-    /**
-     * @see com.intellij.psi.util.TypeConversionUtil#erasure(com.intellij.psi.PsiType)
-     */
-    @Nullable
-    public static JavaType erasure(@NotNull JavaType type) {
-        return erasure(type, JavaTypeSubstitutor.EMPTY);
-    }
-
-    /**
-     * @see com.intellij.psi.util.TypeConversionUtil#erasure(com.intellij.psi.PsiType, com.intellij.psi.PsiSubstitutor)
-     */
-    @Nullable
-    public static JavaType erasure(@NotNull JavaType type, @NotNull JavaTypeSubstitutor substitutor) {
-        if (type instanceof JavaClassifierType) {
-            JavaClassifier classifier = ((JavaClassifierType) type).getClassifier();
-            if (classifier instanceof JavaClass) {
-                return ((JavaClass) classifier).getDefaultType();
-            }
-            else if (classifier instanceof JavaTypeParameter) {
-                JavaTypeParameter typeParameter = (JavaTypeParameter) classifier;
-                return typeParameterErasure(typeParameter, new HashSet<JavaTypeParameter>(), substitutor);
-            }
-            else {
-                return null;
-            }
-        }
-        else if (type instanceof JavaPrimitiveType) {
-            return type;
-        }
-        else if (type instanceof JavaArrayType) {
-            JavaType erasure = erasure(((JavaArrayType) type).getComponentType(), substitutor);
-            return erasure == null ? null : erasure.createArrayType();
-        }
-        else if (type instanceof JavaWildcardType) {
-            JavaWildcardType wildcardType = (JavaWildcardType) type;
-            JavaType bound = wildcardType.getBound();
-            if (bound != null && wildcardType.isExtends()) {
-                return erasure(bound, substitutor);
-            }
-            return wildcardType.getTypeProvider().createJavaLangObjectType();
-        }
-        else {
-            throw new IllegalStateException("Unsupported type: " + type);
-        }
-    }
-
-    /**
-     * @see com.intellij.psi.util.TypeConversionUtil#typeParameterErasure(com.intellij.psi.PsiTypeParameter)
-     */
-    @Nullable
-    private static JavaType typeParameterErasure(
-            @NotNull JavaTypeParameter typeParameter,
-            @NotNull HashSet<JavaTypeParameter> visited,
-            @NotNull JavaTypeSubstitutor substitutor
-    ) {
-        Collection<JavaClassifierType> upperBounds = typeParameter.getUpperBounds();
-        if (!upperBounds.isEmpty()) {
-            JavaClassifier classifier = upperBounds.iterator().next().getClassifier();
-            if (classifier instanceof JavaTypeParameter && !visited.contains(classifier)) {
-                JavaTypeParameter typeParameterBound = (JavaTypeParameter) classifier;
-                visited.add(typeParameterBound);
-                JavaType substitutedType = substitutor.substitute(typeParameterBound);
-                if (substitutedType != null) {
-                    return erasure(substitutedType);
-                }
-                return typeParameterErasure(typeParameterBound, visited, substitutor);
-            }
-            else if (classifier instanceof JavaClass) {
-                return ((JavaClass) classifier).getDefaultType();
-            }
-        }
-        return typeParameter.getTypeProvider().createJavaLangObjectType();
-    }
-
-    @NotNull
-    public static Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> recreateTypeParametersAndReturnMapping(
-            @NotNull List<TypeParameterDescriptor> originalParameters,
-            @Nullable DeclarationDescriptor newOwner
-    ) {
-        // LinkedHashMap to save the order of type parameters
-        Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> result =
-                new LinkedHashMap<TypeParameterDescriptor, TypeParameterDescriptorImpl>();
-        for (TypeParameterDescriptor typeParameter : originalParameters) {
-            result.put(typeParameter,
-                       TypeParameterDescriptorImpl.createForFurtherModification(
-                               newOwner == null ? typeParameter.getContainingDeclaration() : newOwner,
-                               typeParameter.getAnnotations(),
-                               typeParameter.isReified(),
-                               typeParameter.getVariance(),
-                               typeParameter.getName(),
-                               typeParameter.getIndex(),
-                               SourceElement.NO_SOURCE)
-            );
-        }
-        return result;
-    }
-
-    @NotNull
-    public static TypeSubstitutor createSubstitutorForTypeParameters(
-            @NotNull Map<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameters
-    ) {
-        Map<TypeConstructor, TypeProjection> typeSubstitutionContext = new HashMap<TypeConstructor, TypeProjection>();
-        for (Map.Entry<TypeParameterDescriptor, TypeParameterDescriptorImpl> originalToAltTypeParameter : originalToAltTypeParameters
-                .entrySet()) {
-            typeSubstitutionContext.put(originalToAltTypeParameter.getKey().getTypeConstructor(),
-                                        new TypeProjectionImpl(originalToAltTypeParameter.getValue().getDefaultType()));
-        }
-        return TypeSubstitutor.create(typeSubstitutionContext);
-    }
 }