From 66d27fad136532b77e28ef038142263c63c3182e Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Mon, 10 Nov 2014 19:22:35 +0300 Subject: [PATCH] Move utilities out of 'core' to where they are used --- .../resolve/java/JavaResolverPsiUtils.java | 123 +++++++++++++++++- .../AlternativeMethodSignatureData.java | 6 +- .../SignaturesPropagationData.java | 4 +- .../java/sam/SingleAbstractMethodUtils.java | 9 +- .../resolver/DescriptorResolverUtils.java | 120 +---------------- 5 files changed, 136 insertions(+), 126 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaResolverPsiUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaResolverPsiUtils.java index ee56f4cc061..f55de9d8adb 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaResolverPsiUtils.java +++ b/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(), 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 visited, + @NotNull JavaTypeSubstitutor substitutor + ) { + Collection 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 recreateTypeParametersAndReturnMapping( + @NotNull List originalParameters, + @Nullable DeclarationDescriptor newOwner + ) { + // LinkedHashMap to save the order of type parameters + Map result = + new LinkedHashMap(); + 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 originalToAltTypeParameters + ) { + Map typeSubstitutionContext = new HashMap(); + for (Map.Entry originalToAltTypeParameter : originalToAltTypeParameters.entrySet()) { + typeSubstitutionContext.put(originalToAltTypeParameter.getKey().getTypeConstructor(), + new TypeProjectionImpl(originalToAltTypeParameter.getValue().getDefaultType())); + } + return TypeSubstitutor.create(typeSubstitutionContext); + } } 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 db8fdf306ff..7b7fbbb1217 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 @@ -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(); 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 5c6280cd0c6..cc66629c713 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 @@ -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); diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java index 146c91e15c9..0557f5ce5dc 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/sam/SingleAbstractMethodUtils.java +++ b/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 traitToFunTypeParameters = - DescriptorResolverUtils.recreateTypeParametersAndReturnMapping(originalParameters, newOwner); - TypeSubstitutor typeParametersSubstitutor = DescriptorResolverUtils.createSubstitutorForTypeParameters(traitToFunTypeParameters); + JavaResolverPsiUtils.recreateTypeParametersAndReturnMapping(originalParameters, newOwner); + TypeSubstitutor typeParametersSubstitutor = JavaResolverPsiUtils.createSubstitutorForTypeParameters(traitToFunTypeParameters); for (Map.Entry 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 type2 = DescriptorResolverUtils.erasure(substitutor2.substitute(param2.getType()), substitutor2); + JavaType type1 = JavaResolverPsiUtils.erasure(substitutor1.substitute(param1.getType()), substitutor1); + JavaType type2 = JavaResolverPsiUtils.erasure(substitutor2.substitute(param2.getType()), substitutor2); if (!(type1 == null ? type2 == null : type1.equals(type2))) return false; } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java index 401a755c706..fe0b97321e8 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DescriptorResolverUtils.java +++ b/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.impl.TypeParameterDescriptorImpl; +import org.jetbrains.jet.lang.descriptors.CallableMemberDescriptor; +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(), 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 visited, - @NotNull JavaTypeSubstitutor substitutor - ) { - Collection 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 recreateTypeParametersAndReturnMapping( - @NotNull List originalParameters, - @Nullable DeclarationDescriptor newOwner - ) { - // LinkedHashMap to save the order of type parameters - Map result = - new LinkedHashMap(); - 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 originalToAltTypeParameters - ) { - Map typeSubstitutionContext = new HashMap(); - for (Map.Entry originalToAltTypeParameter : originalToAltTypeParameters - .entrySet()) { - typeSubstitutionContext.put(originalToAltTypeParameter.getKey().getTypeConstructor(), - new TypeProjectionImpl(originalToAltTypeParameter.getValue().getDefaultType())); - } - return TypeSubstitutor.create(typeSubstitutionContext); - } }