From ea7036d808f83de7dce441b58119a195641508c2 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 25 Jul 2013 15:38:38 +0400 Subject: [PATCH] Minor, move utilities to where they are used --- .../resolve/java/DescriptorResolverUtils.java | 52 ++++--------------- .../resolve/java/JavaToKotlinClassMap.java | 26 ++++++++-- .../java/resolver/JavaClassResolver.java | 19 +++++-- .../java/resolver/JavaSupertypeResolver.java | 25 ++------- 4 files changed, 54 insertions(+), 68 deletions(-) diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java index f561fb801c5..6c52398cb78 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/DescriptorResolverUtils.java @@ -22,12 +22,9 @@ import com.intellij.psi.util.PsiFormatUtil; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.*; -import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.BindingTrace; -import org.jetbrains.jet.lang.resolve.constants.StringValue; import org.jetbrains.jet.lang.resolve.java.resolver.ErrorReporter; import org.jetbrains.jet.lang.resolve.name.FqName; -import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; @@ -36,31 +33,27 @@ import java.util.Collections; import java.util.List; import static com.intellij.psi.util.PsiFormatUtilBase.*; -import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isEnumClassObject; public final class DescriptorResolverUtils { - - public static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object"); - private DescriptorResolverUtils() { } public static boolean isCompiledKotlinPackageClass(@NotNull PsiClass psiClass) { - if (!(psiClass instanceof ClsClassImpl)) { - return false; + if (psiClass instanceof ClsClassImpl) { + String qualifiedName = psiClass.getQualifiedName(); + if (qualifiedName != null && PackageClassUtils.isPackageClassFqName(new FqName(qualifiedName))) { + return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()); + } } - if (!PackageClassUtils.isPackageClassFqName(new FqName(psiClass.getQualifiedName()))) { - return false; - } - return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()); + return false; } public static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) { - if (!(psiClass instanceof ClsClassImpl)) { - return false; + if (psiClass instanceof ClsClassImpl) { + return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName()); } - return hasAnnotation(psiClass, JvmAnnotationNames.KOTLIN_CLASS.getFqName()); + return false; } public static boolean hasAnnotation(@NotNull PsiClass psiClass, @NotNull FqName annotationFqName) { @@ -83,9 +76,7 @@ public final class DescriptorResolverUtils { return Collections.emptyList(); } - public static Visibility resolveVisibility( - @NotNull PsiModifierListOwner modifierListOwner - ) { + public static Visibility resolveVisibility(@NotNull PsiModifierListOwner modifierListOwner) { if (modifierListOwner.hasModifierProperty(PsiModifier.PUBLIC)) { return Visibilities.PUBLIC; } @@ -119,29 +110,6 @@ public final class DescriptorResolverUtils { return null; } - public static void checkPsiClassIsNotJet(@Nullable PsiClass psiClass) { - if (psiClass instanceof JetJavaMirrorMarker) { - throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName()); - } - } - - @NotNull - public static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) { - String psiClassQualifiedName = psiClass.getQualifiedName(); - assert psiClassQualifiedName != null : "Reading java class with no qualified name"; - return new FqNameUnsafe(psiClassQualifiedName + "." + getClassObjectName(psiClass.getName()).asString()); - } - - @NotNull - public static AnnotationDescriptor getAnnotationDescriptorForJavaLangDeprecated(ClassDescriptor classDescriptor) { - AnnotationDescriptor annotationDescriptor = new AnnotationDescriptor(); - annotationDescriptor.setAnnotationType(classDescriptor.getDefaultType()); - ValueParameterDescriptor value = getValueParameterDescriptorForAnnotationParameter(Name.identifier("value"), classDescriptor); - assert value != null : "jet.deprecated must have one parameter called value"; - annotationDescriptor.setValueArgument(value, new StringValue("Deprecated in Java")); - return annotationDescriptor; - } - /** * @return true if {@code member} is a static member of enum class, which is to be put into its class object (and not into the * corresponding package). This applies to enum entries, values() and valueOf(String) methods diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java index 5de6852d9a6..45a1635b871 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/JavaToKotlinClassMap.java @@ -16,22 +16,31 @@ package org.jetbrains.jet.lang.resolve.java; -import com.google.common.collect.*; +import com.google.common.collect.HashMultimap; +import com.google.common.collect.Lists; +import com.google.common.collect.Maps; +import com.google.common.collect.Multimap; import com.intellij.psi.CommonClassNames; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.PlatformToKotlinClassMap; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; 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.resolve.DescriptorUtils; +import org.jetbrains.jet.lang.resolve.constants.StringValue; import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe; +import org.jetbrains.jet.lang.resolve.name.Name; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lang.types.lang.PrimitiveType; -import java.util.*; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Map; public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements PlatformToKotlinClassMap { private static JavaToKotlinClassMap instance = null; @@ -92,11 +101,22 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements public AnnotationDescriptor mapToAnnotationClass(@NotNull FqName fqName) { ClassDescriptor classDescriptor = classDescriptorMap.get(fqName); if (classDescriptor != null && fqName.asString().equals(CommonClassNames.JAVA_LANG_DEPRECATED)) { - return DescriptorResolverUtils.getAnnotationDescriptorForJavaLangDeprecated(classDescriptor); + return getAnnotationDescriptorForJavaLangDeprecated(classDescriptor); } return null; } + @NotNull + private static AnnotationDescriptor getAnnotationDescriptorForJavaLangDeprecated(@NotNull ClassDescriptor classDescriptor) { + AnnotationDescriptor annotation = new AnnotationDescriptor(); + annotation.setAnnotationType(classDescriptor.getDefaultType()); + ValueParameterDescriptor value = + DescriptorResolverUtils.getValueParameterDescriptorForAnnotationParameter(Name.identifier("value"), classDescriptor); + assert value != null : "jet.deprecated must have one parameter called value"; + annotation.setValueArgument(value, new StringValue("Deprecated in Java")); + return annotation; + } + private static FqName getJavaClassFqName(@NotNull Class javaClass) { return new FqName(javaClass.getName().replace('$', '.')); } 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 498ef57c57d..a48adf5a8ac 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 @@ -236,7 +236,7 @@ public final class JavaClassResolver { @NotNull PostponedTasks taskList ) { checkFqNamesAreConsistent(psiClass, fqName); - DescriptorResolverUtils.checkPsiClassIsNotJet(psiClass); + checkPsiClassIsNotJet(psiClass); ClassOrNamespaceDescriptor containingDeclaration = resolveParentDescriptor(psiClass); // class may be resolved during resolution of parent @@ -304,7 +304,7 @@ public final class JavaClassResolver { if (psiClass.isEnum()) { ClassDescriptorFromJvmBytecode classObjectDescriptor = createClassObjectDescriptorForEnum(classDescriptor, psiClass); - cache(DescriptorResolverUtils.getFqNameForClassObject(psiClass), classObjectDescriptor); + cache(getFqNameForClassObject(psiClass), classObjectDescriptor); classDescriptor.getBuilder().setClassObjectDescriptor(classObjectDescriptor); } @@ -321,6 +321,13 @@ public final class JavaClassResolver { return classDescriptor; } + @NotNull + private static FqNameUnsafe getFqNameForClassObject(@NotNull PsiClass psiClass) { + String qualifiedName = psiClass.getQualifiedName(); + assert qualifiedName != null : "Reading java class with no qualified name"; + return new FqNameUnsafe(qualifiedName + "." + getClassObjectName(psiClass.getName()).asString()); + } + @NotNull private SimpleFunctionDescriptor resolveFunctionOfSamInterface( @NotNull PsiMethod samInterfaceMethod, @@ -393,7 +400,7 @@ public final class JavaClassResolver { !psiClass.hasModifierProperty(PsiModifier.FINAL)); } - void checkFqNamesAreConsistent(@NotNull PsiClass psiClass, @NotNull FqName desiredFqName) { + private void checkFqNamesAreConsistent(@NotNull PsiClass psiClass, @NotNull FqName desiredFqName) { String qualifiedName = psiClass.getQualifiedName(); assert qualifiedName != null; @@ -405,6 +412,12 @@ public final class JavaClassResolver { } } + private static void checkPsiClassIsNotJet(@NotNull PsiClass psiClass) { + if (psiClass instanceof JetJavaMirrorMarker) { + throw new IllegalStateException("trying to resolve fake jet PsiClass as regular PsiClass: " + psiClass.getQualifiedName()); + } + } + @NotNull private ClassOrNamespaceDescriptor resolveParentDescriptor(@NotNull PsiClass psiClass) { if (isContainedInClass(psiClass)) { 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 4b23501237a..0a055c3d390 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 @@ -19,13 +19,13 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.intellij.psi.PsiClass; import com.intellij.psi.PsiClassType; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.descriptors.ClassDescriptor; import org.jetbrains.jet.lang.descriptors.ClassKind; import org.jetbrains.jet.lang.descriptors.TypeParameterDescriptor; import org.jetbrains.jet.lang.resolve.BindingContext; import org.jetbrains.jet.lang.resolve.BindingTrace; import org.jetbrains.jet.lang.resolve.java.*; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.ErrorUtils; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; @@ -37,6 +37,7 @@ import java.util.Collection; import java.util.List; public final class JavaSupertypeResolver { + private static final FqName OBJECT_FQ_NAME = new FqName("java.lang.Object"); private BindingTrace trace; private JavaTypeTransformer typeTransformer; @@ -79,17 +80,12 @@ public final class JavaSupertypeResolver { return result; } - private void addBaseClass( - @NotNull PsiClass psiClass, - @NotNull ClassDescriptor classDescriptor, - @NotNull List result - ) { - if (DescriptorResolverUtils.OBJECT_FQ_NAME.equalsTo(psiClass.getQualifiedName()) - || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { + private void addBaseClass(@NotNull PsiClass psiClass, @NotNull ClassDescriptor classDescriptor, @NotNull List result) { + if (OBJECT_FQ_NAME.asString().equals(psiClass.getQualifiedName()) || classDescriptor.getKind() == ClassKind.ANNOTATION_CLASS) { result.add(KotlinBuiltIns.getInstance().getAnyType()); } else { - ClassDescriptor object = resolveJavaLangObject(); + ClassDescriptor object = classResolver.resolveClass(OBJECT_FQ_NAME, DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); if (object != null) { result.add(object.getDefaultType()); } @@ -133,15 +129,4 @@ public final class JavaSupertypeResolver { result.add(TypeUtils.makeNotNullable(transform)); } } - - - @Nullable - private ClassDescriptor resolveJavaLangObject() { - ClassDescriptor clazz = classResolver.resolveClass(DescriptorResolverUtils.OBJECT_FQ_NAME, - DescriptorSearchRule.IGNORE_IF_FOUND_IN_KOTLIN); - if (clazz == null) { - // TODO: warning - } - return clazz; - } }