From 45bc7c292629fab0324900e86a26b731026991c1 Mon Sep 17 00:00:00 2001 From: Alexander Udalov Date: Thu, 26 Sep 2013 22:19:35 +0400 Subject: [PATCH] Delete JvmClassName.byClass, refactor JvmAnnotationNames Store constant class names as instances of FqName instead of JvmClassName. This is done to minimize usages of the method 'JvmClassName.getFqName()', since it's wrong and shouldn't be used --- .../org/jetbrains/jet/codegen/AsmUtil.java | 10 +++--- .../jet/codegen/FunctionCodegen.java | 4 ++- .../codegen/ImplementationBodyCodegen.java | 2 +- .../jet/codegen/NamespaceCodegen.java | 6 ++-- .../java/kotlinSignature/SignaturesUtil.java | 13 ++++++-- .../PsiBasedExternalAnnotationResolver.java | 8 ----- .../IdeaJdkAnnotationsReflectedTest.java | 6 ++-- .../lang/resolve/java/JvmAnnotationNames.java | 31 ++++++------------- .../jet/lang/resolve/java/JvmClassName.java | 5 --- .../java/mapping/JavaToKotlinClassMap.java | 16 +++------- .../resolver/DescriptorResolverUtils.java | 9 ++++-- .../java/resolver/JavaAnnotationResolver.java | 23 ++++++++------ .../java/resolver/JavaClassResolver.java | 6 ++-- .../AnnotationDescriptorDeserializer.java | 6 ++-- .../header/ReadDataFromAnnotationVisitor.java | 5 +-- .../ktSignature/KotlinSignatureUtil.java | 9 +++--- .../versions/KotlinAbiVersionIndex.java | 23 +++++++++----- 17 files changed, 93 insertions(+), 89 deletions(-) diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java index a0d9ff374c4..1fdc00c81a8 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/AsmUtil.java @@ -32,11 +32,9 @@ import org.jetbrains.jet.codegen.state.JetTypeMapper; import org.jetbrains.jet.lang.descriptors.*; import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall; -import org.jetbrains.jet.lang.resolve.java.AsmTypeConstants; -import org.jetbrains.jet.lang.resolve.java.JavaVisibilities; -import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.JvmPrimitiveType; +import org.jetbrains.jet.lang.resolve.java.*; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaCallableMemberDescriptor; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; import org.jetbrains.jet.lexer.JetTokens; @@ -667,4 +665,8 @@ public class AsmUtil { } } + @NotNull + public static String asmDescByFqNameWithoutInnerClasses(@NotNull FqName fqName) { + return JvmClassName.byFqNameWithoutInnerClasses(fqName).getDescriptor(); + } } diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java index 1d53e60e373..3d2b2ad5850 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/FunctionCodegen.java @@ -57,6 +57,7 @@ import static org.jetbrains.jet.lang.resolve.BindingContextUtils.callableDescrip import static org.jetbrains.jet.lang.resolve.BindingContextUtils.descriptorToDeclaration; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.isFunctionLiteral; import static org.jetbrains.jet.lang.resolve.java.AsmTypeConstants.OBJECT_TYPE; +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; public class FunctionCodegen extends GenerationStateAware { private final CodegenContext owner; @@ -190,7 +191,8 @@ public class FunctionCodegen extends GenerationStateAware { } } - AnnotationVisitor av = mv.visitParameterAnnotation(i, JvmClassName.byClass(JetValueParameter.class).getDescriptor(), true); + AnnotationVisitor av = + mv.visitParameterAnnotation(i, asmDescByFqNameWithoutInnerClasses(fqNameByClass(JetValueParameter.class)), true); av.visit("name", name); if (nullableType) { av.visit("type", "?"); diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java index bac1442048a..5ba51e63bce 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java @@ -227,7 +227,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen { ClassData data = new ClassData(createNameResolver(serializer.getNameTable()), classProto); - AnnotationVisitor av = v.getVisitor().visitAnnotation(JvmAnnotationNames.KOTLIN_CLASS.getDescriptor(), true); + AnnotationVisitor av = v.getVisitor().visitAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_CLASS), true); av.visit(JvmAnnotationNames.ABI_VERSION_FIELD_NAME, JvmAbi.VERSION); AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME); for (String string : BitEncoding.encodeBytes(data.toBytes())) { diff --git a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java index 729f2270587..52c113b61a8 100644 --- a/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java +++ b/compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java @@ -54,6 +54,7 @@ import java.util.Collections; import java.util.List; import static org.jetbrains.asm4.Opcodes.*; +import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses; import static org.jetbrains.jet.descriptors.serialization.NameSerializationUtil.createNameResolver; public class NamespaceCodegen extends MemberCodegen { @@ -152,7 +153,8 @@ public class NamespaceCodegen extends MemberCodegen { PackageData data = new PackageData(createNameResolver(serializer.getNameTable()), packageProto); - AnnotationVisitor av = v.getClassBuilder().newAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE.getDescriptor(), true); + AnnotationVisitor av = + v.getClassBuilder().newAnnotation(asmDescByFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE), true); av.visit(JvmAnnotationNames.ABI_VERSION_FIELD_NAME, JvmAbi.VERSION); AnnotationVisitor array = av.visitArray(JvmAnnotationNames.DATA_FIELD_NAME); for (String string : BitEncoding.encodeBytes(data.toBytes())) { @@ -215,7 +217,7 @@ public class NamespaceCodegen extends MemberCodegen { } private static void writeKotlinPackageFragmentAnnotation(@NotNull ClassBuilder builder) { - AnnotationVisitor av = builder.newAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE_FRAGMENT.getDescriptor(), true); + AnnotationVisitor av = builder.newAnnotation(JvmClassName.byFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE_FRAGMENT).getDescriptor(), true); av.visit(JvmAnnotationNames.ABI_VERSION_FIELD_NAME, JvmAbi.VERSION); av.visitEnd(); } diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java index 56183dc27a1..a54baa1b5e3 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kotlinSignature/SignaturesUtil.java @@ -17,25 +17,32 @@ package org.jetbrains.jet.lang.resolve.java.kotlinSignature; import com.intellij.openapi.util.text.StringUtil; +import jet.runtime.typeinfo.KotlinSignature; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationArgument; import org.jetbrains.jet.lang.resolve.java.structure.JavaLiteralAnnotationArgument; import org.jetbrains.jet.lang.resolve.java.structure.JavaMember; +import org.jetbrains.jet.lang.resolve.name.FqName; +import org.jetbrains.jet.lang.resolve.name.Name; + +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; public class SignaturesUtil { + public static final FqName KOTLIN_SIGNATURE = fqNameByClass(KotlinSignature.class); + public static final Name KOTLIN_SIGNATURE_VALUE_FIELD_NAME = Name.identifier("value"); + private SignaturesUtil() { } @Nullable public static String getKotlinSignature(@NotNull JavaAnnotationResolver annotationResolver, @NotNull JavaMember member) { - JavaAnnotation annotation = annotationResolver.findAnnotationWithExternal(member, JvmAnnotationNames.KOTLIN_SIGNATURE); + JavaAnnotation annotation = annotationResolver.findAnnotationWithExternal(member, KOTLIN_SIGNATURE); if (annotation != null) { - JavaAnnotationArgument argument = annotation.findArgument(JvmAnnotationNames.KOTLIN_SIGNATURE_VALUE_FIELD_NAME); + JavaAnnotationArgument argument = annotation.findArgument(KOTLIN_SIGNATURE_VALUE_FIELD_NAME); if (argument instanceof JavaLiteralAnnotationArgument) { Object value = ((JavaLiteralAnnotationArgument) argument).getValue(); if (value instanceof String) { diff --git a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java index 67457eee3af..2c065607d3e 100644 --- a/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java +++ b/compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/PsiBasedExternalAnnotationResolver.java @@ -18,11 +18,9 @@ package org.jetbrains.jet.lang.resolve.java.resolver; import com.intellij.codeInsight.ExternalAnnotationsManager; import com.intellij.psi.PsiAnnotation; -import com.intellij.psi.PsiModifierList; import com.intellij.psi.PsiModifierListOwner; import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; -import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationOwner; import org.jetbrains.jet.lang.resolve.java.structure.impl.JavaAnnotationImpl; @@ -55,10 +53,4 @@ public class PsiBasedExternalAnnotationResolver implements ExternalAnnotationRes public static PsiAnnotation findExternalAnnotation(@NotNull PsiModifierListOwner owner, @NotNull FqName fqName) { return ExternalAnnotationsManager.getInstance(owner.getProject()).findExternalAnnotation(owner, fqName.asString()); } - - @Nullable - public static PsiAnnotation findOwnAnnotation(@NotNull PsiModifierListOwner owner, @NotNull JvmClassName name) { - PsiModifierList list = owner.getModifierList(); - return list == null ? null : list.findAnnotation(name.getFqName().asString()); - } } diff --git a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java index e5fd93aa1c3..6610b8d54d8 100644 --- a/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java +++ b/compiler/tests/org/jetbrains/jet/jvm/compiler/IdeaJdkAnnotationsReflectedTest.java @@ -30,7 +30,7 @@ import org.jetbrains.jet.JetTestUtils; import org.jetbrains.jet.TestJdkKind; import org.jetbrains.jet.cli.jvm.compiler.CoreExternalAnnotationsManager; import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; +import org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil; import org.jetbrains.jet.lang.resolve.lazy.KotlinTestWithEnvironment; import org.jetbrains.jet.lang.resolve.name.FqName; @@ -158,9 +158,9 @@ public class IdeaJdkAnnotationsReflectedTest extends KotlinTestWithEnvironment { } private enum AnnotationsKind { - KOTLIN_SIGNATURE(JvmAnnotationNames.KOTLIN_SIGNATURE.getFqName().asString()), + KOTLIN_SIGNATURE(SignaturesUtil.KOTLIN_SIGNATURE.asString()), NOT_NULL(AnnotationUtil.NOT_NULL), - ANY(AnnotationUtil.NOT_NULL, JvmAnnotationNames.KOTLIN_SIGNATURE.getFqName().asString()); + ANY(AnnotationUtil.NOT_NULL, SignaturesUtil.KOTLIN_SIGNATURE.asString()); public final String[] annotationNames; diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java index 1f0ed1b5ae3..291324e39c0 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmAnnotationNames.java @@ -19,37 +19,26 @@ package org.jetbrains.jet.lang.resolve.java; import jet.KotlinClass; import jet.KotlinPackage; import jet.KotlinPackageFragment; -import jet.runtime.typeinfo.KotlinSignature; -import org.jetbrains.annotations.NotNull; -import org.jetbrains.jet.lang.resolve.name.Name; -import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver; +import org.jetbrains.jet.lang.resolve.name.FqName; + +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; public final class JvmAnnotationNames { - public static final JvmClassName KOTLIN_CLASS = JvmClassName.byClass(KotlinClass.class); + public static final FqName KOTLIN_CLASS = fqNameByClass(KotlinClass.class); - public static final JvmClassName KOTLIN_PACKAGE = JvmClassName.byClass(KotlinPackage.class); + public static final FqName KOTLIN_PACKAGE = fqNameByClass(KotlinPackage.class); - public static final JvmClassName KOTLIN_PACKAGE_FRAGMENT = JvmClassName.byClass(KotlinPackageFragment.class); + public static final FqName KOTLIN_PACKAGE_FRAGMENT = fqNameByClass(KotlinPackageFragment.class); public static final String ABI_VERSION_FIELD_NAME = "abiVersion"; public static final String DATA_FIELD_NAME = "data"; + @Deprecated - public static final JvmClassName OLD_JET_CLASS_ANNOTATION = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetClass"); + public static final FqName OLD_JET_CLASS_ANNOTATION = new FqName("jet.runtime.typeinfo.JetClass"); + @Deprecated - public static final JvmClassName OLD_JET_PACKAGE_CLASS_ANNOTATION = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetPackageClass"); - - public static final JvmClassName ASSERT_INVISIBLE_IN_RESOLVER = JvmClassName.byClass(AssertInvisibleInResolver.class); - - public static final JvmClassName KOTLIN_SIGNATURE = JvmClassName.byClass(KotlinSignature.class); - - public static final Name KOTLIN_SIGNATURE_VALUE_FIELD_NAME = Name.identifier("value"); - - public static final JvmClassName JETBRAINS_NOT_NULL_ANNOTATION = JvmClassName.byClass(NotNull.class); - - public static final JvmClassName JETBRAINS_MUTABLE_ANNOTATION = JvmClassName.byFqNameWithoutInnerClasses("org.jetbrains.annotations.Mutable"); - - public static final JvmClassName JETBRAINS_READONLY_ANNOTATION = JvmClassName.byFqNameWithoutInnerClasses("org.jetbrains.annotations.ReadOnly"); + public static final FqName OLD_JET_PACKAGE_CLASS_ANNOTATION = new FqName("jet.runtime.typeinfo.JetPackageClass"); private JvmAnnotationNames() { } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java index a41fded25a7..ba320c064a7 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/JvmClassName.java @@ -51,11 +51,6 @@ public class JvmClassName { return byFqNameWithoutInnerClasses(new FqName(fqName)); } - @NotNull - public static JvmClassName byClass(@NotNull Class klass) { - return byFqNameWithoutInnerClasses(new FqName(klass.getCanonicalName())); - } - @NotNull private static String encodeSpecialNames(@NotNull String str) { String encodedObjectNames = StringUtil.replace(str, JvmAbi.CLASS_OBJECT_CLASS_NAME, CLASS_OBJECT_REPLACE_GUARD); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java index 3684c9db3bb..9eea51413a2 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/mapping/JavaToKotlinClassMap.java @@ -39,6 +39,8 @@ import org.jetbrains.jet.lang.types.lang.PrimitiveType; import java.util.*; +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; + public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements PlatformToKotlinClassMap { private static final FqName JAVA_LANG_DEPRECATED = new FqName("java.lang.Deprecated"); @@ -113,18 +115,10 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements return annotation; } - private static FqName getJavaClassFqName(@NotNull Class javaClass) { - return new FqName(javaClass.getName().replace('$', '.')); - } - @Override - protected void register( - @NotNull Class javaClass, - @NotNull ClassDescriptor kotlinDescriptor, - @NotNull Direction direction - ) { + protected void register(@NotNull Class javaClass, @NotNull ClassDescriptor kotlinDescriptor, @NotNull Direction direction) { if (direction == Direction.BOTH || direction == Direction.JAVA_TO_KOTLIN) { - register(getJavaClassFqName(javaClass), kotlinDescriptor); + register(fqNameByClass(javaClass), kotlinDescriptor); } } @@ -136,7 +130,7 @@ public class JavaToKotlinClassMap extends JavaToKotlinClassMapBuilder implements @NotNull Direction direction ) { if (direction == Direction.BOTH || direction == Direction.JAVA_TO_KOTLIN) { - FqName javaClassName = getJavaClassFqName(javaClass); + FqName javaClassName = fqNameByClass(javaClass); register(javaClassName, kotlinDescriptor); registerCovariant(javaClassName, kotlinMutableDescriptor); } 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 5996fb0c940..00ba2a5a34a 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 @@ -43,7 +43,7 @@ public final class DescriptorResolverUtils { if (javaClass.getOriginKind() == JavaClass.OriginKind.COMPILED) { FqName fqName = javaClass.getFqName(); if (fqName != null && PackageClassUtils.isPackageClassFqName(fqName)) { - return javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()) != null; + return javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_PACKAGE) != null; } } return false; @@ -51,7 +51,7 @@ public final class DescriptorResolverUtils { public static boolean isCompiledKotlinClass(@NotNull JavaClass javaClass) { if (javaClass.getOriginKind() == JavaClass.OriginKind.COMPILED) { - return javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_CLASS.getFqName()) != null; + return javaClass.findAnnotation(JvmAnnotationNames.KOTLIN_CLASS) != null; } return false; } @@ -60,6 +60,11 @@ public final class DescriptorResolverUtils { return isCompiledKotlinClass(javaClass) || isCompiledKotlinPackageClass(javaClass); } + @NotNull + public static FqName fqNameByClass(@NotNull Class clazz) { + return new FqName(clazz.getCanonicalName()); + } + @NotNull public static Collection resolveOverrides( @NotNull Name name, diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java index ef4ae6746c0..fcec3c88702 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java @@ -23,7 +23,6 @@ import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor; import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor; import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant; import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; -import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.java.mapping.JavaToKotlinClassMap; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotation; import org.jetbrains.jet.lang.resolve.java.structure.JavaAnnotationArgument; @@ -37,9 +36,13 @@ import java.util.Collection; import java.util.List; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; public final class JavaAnnotationResolver { public static final Name DEFAULT_ANNOTATION_MEMBER_NAME = Name.identifier("value"); + public static final FqName JETBRAINS_NOT_NULL_ANNOTATION = fqNameByClass(NotNull.class); + public static final FqName JETBRAINS_MUTABLE_ANNOTATION = new FqName("org.jetbrains.annotations.Mutable"); + public static final FqName JETBRAINS_READONLY_ANNOTATION = new FqName("org.jetbrains.annotations.ReadOnly"); private JavaClassResolver classResolver; private JavaAnnotationArgumentResolver argumentResolver; @@ -102,9 +105,9 @@ public final class JavaAnnotationResolver { // Don't process internal jet annotations and jetbrains NotNull annotations if (fqName.asString().startsWith("jet.runtime.typeinfo.") - || fqName.equals(JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION.getFqName()) - || fqName.equals(JvmAnnotationNames.KOTLIN_CLASS.getFqName()) - || fqName.equals(JvmAnnotationNames.KOTLIN_PACKAGE.getFqName()) + || fqName.equals(JETBRAINS_NOT_NULL_ANNOTATION) + || fqName.equals(JvmAnnotationNames.KOTLIN_CLASS) + || fqName.equals(JvmAnnotationNames.KOTLIN_PACKAGE) ) { return null; } @@ -143,24 +146,24 @@ public final class JavaAnnotationResolver { } @Nullable - public JavaAnnotation findAnnotationWithExternal(@NotNull JavaAnnotationOwner owner, @NotNull JvmClassName name) { - JavaAnnotation annotation = owner.findAnnotation(name.getFqName()); + public JavaAnnotation findAnnotationWithExternal(@NotNull JavaAnnotationOwner owner, @NotNull FqName name) { + JavaAnnotation annotation = owner.findAnnotation(name); if (annotation != null) { return annotation; } - return externalAnnotationResolver.findExternalAnnotation(owner, name.getFqName()); + return externalAnnotationResolver.findExternalAnnotation(owner, name); } public boolean hasNotNullAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_NOT_NULL_ANNOTATION) != null; + return findAnnotationWithExternal(owner, JETBRAINS_NOT_NULL_ANNOTATION) != null; } public boolean hasMutableAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_MUTABLE_ANNOTATION) != null; + return findAnnotationWithExternal(owner, JETBRAINS_MUTABLE_ANNOTATION) != null; } public boolean hasReadonlyAnnotation(@NotNull JavaAnnotationOwner owner) { - return findAnnotationWithExternal(owner, JvmAnnotationNames.JETBRAINS_READONLY_ANNOTATION) != null; + return findAnnotationWithExternal(owner, JETBRAINS_READONLY_ANNOTATION) != null; } } \ No newline at end of file diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java index 262cce0bb53..48d7b65363d 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaClassResolver.java @@ -26,7 +26,6 @@ import org.jetbrains.jet.lang.resolve.DescriptorUtils; import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule; import org.jetbrains.jet.lang.resolve.java.JavaClassFinder; import org.jetbrains.jet.lang.resolve.java.JvmAbi; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; import org.jetbrains.jet.lang.resolve.java.descriptor.ClassDescriptorFromJvmBytecode; import org.jetbrains.jet.lang.resolve.java.descriptor.JavaEnumClassObjectDescriptor; import org.jetbrains.jet.lang.resolve.java.sam.SingleAbstractMethodUtils; @@ -48,14 +47,17 @@ import org.jetbrains.jet.lang.types.JetType; import org.jetbrains.jet.lang.types.TypeUtils; import org.jetbrains.jet.lang.types.checker.JetTypeChecker; import org.jetbrains.jet.lang.types.lang.KotlinBuiltIns; +import org.jetbrains.jet.rt.annotation.AssertInvisibleInResolver; import javax.inject.Inject; import java.util.*; import static org.jetbrains.jet.lang.resolve.DescriptorUtils.getClassObjectName; import static org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule.INCLUDE_KOTLIN_SOURCES; +import static org.jetbrains.jet.lang.resolve.java.resolver.DescriptorResolverUtils.fqNameByClass; public final class JavaClassResolver { + private static final FqName ASSERT_INVISIBLE_IN_RESOLVER_ANNOTATION = fqNameByClass(AssertInvisibleInResolver.class); private static final Logger LOG = Logger.getInstance(JavaClassResolver.class); @NotNull @@ -207,7 +209,7 @@ public final class JavaClassResolver { } if (KotlinBuiltIns.BUILT_INS_PACKAGE_FQ_NAME.equals(qualifiedName.parent())) { - if (javaClass.findAnnotation(JvmAnnotationNames.ASSERT_INVISIBLE_IN_RESOLVER.getFqName()) != null) { + if (javaClass.findAnnotation(ASSERT_INVISIBLE_IN_RESOLVER_ANNOTATION) != null) { if (ApplicationManager.getApplication().isInternal()) { LOG.error("classpath is configured incorrectly:" + " class " + qualifiedName + " from runtime must not be loaded by compiler"); diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java index fcfd5552e3e..14a7af24cdd 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/AnnotationDescriptorDeserializer.java @@ -138,9 +138,9 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer } private static boolean ignoreAnnotation(@NotNull JvmClassName className) { - // TODO: JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION ? - return className.equals(JvmAnnotationNames.KOTLIN_CLASS) - || className.equals(JvmAnnotationNames.KOTLIN_PACKAGE) + // TODO: JETBRAINS_NOT_NULL_ANNOTATION ? + return className.equals(JvmClassName.byFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_CLASS)) + || className.equals(JvmClassName.byFqNameWithoutInnerClasses(JvmAnnotationNames.KOTLIN_PACKAGE)) || className.getInternalName().startsWith("jet/runtime/typeinfo/"); } diff --git a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/header/ReadDataFromAnnotationVisitor.java b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/header/ReadDataFromAnnotationVisitor.java index 712f9a8e787..0cb6e87a2e5 100644 --- a/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/header/ReadDataFromAnnotationVisitor.java +++ b/core/descriptor.loader.java/src/org/jetbrains/jet/lang/resolve/kotlin/header/ReadDataFromAnnotationVisitor.java @@ -23,6 +23,7 @@ import org.jetbrains.jet.lang.resolve.java.AbiVersionUtil; import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; import org.jetbrains.jet.lang.resolve.java.JvmClassName; import org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass; +import org.jetbrains.jet.lang.resolve.name.FqName; import org.jetbrains.jet.lang.resolve.name.Name; import java.util.ArrayList; @@ -46,8 +47,8 @@ import static org.jetbrains.jet.lang.resolve.kotlin.KotlinJvmBinaryClass.Annotat @NotNull private final JvmClassName annotation; - private HeaderType(@NotNull JvmClassName annotation) { - this.annotation = annotation; + private HeaderType(@NotNull FqName annotation) { + this.annotation = JvmClassName.byFqNameWithoutInnerClasses(annotation); } @Nullable diff --git a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java index 50d6bcbdc03..1d6c78e1de4 100644 --- a/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java +++ b/idea/src/org/jetbrains/jet/plugin/ktSignature/KotlinSignatureUtil.java @@ -28,10 +28,10 @@ import org.jetbrains.annotations.NotNull; import org.jetbrains.annotations.Nullable; import org.jetbrains.jet.lang.resolve.java.resolver.PsiBasedExternalAnnotationResolver; -import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.KOTLIN_SIGNATURE; +import static org.jetbrains.jet.lang.resolve.java.kotlinSignature.SignaturesUtil.KOTLIN_SIGNATURE; class KotlinSignatureUtil { - static final String KOTLIN_SIGNATURE_ANNOTATION = KOTLIN_SIGNATURE.getFqName().asString(); + static final String KOTLIN_SIGNATURE_ANNOTATION = KOTLIN_SIGNATURE.asString(); private KotlinSignatureUtil() { } @@ -81,10 +81,11 @@ class KotlinSignatureUtil { static PsiAnnotation findKotlinSignatureAnnotation(@NotNull PsiElement element) { if (!(element instanceof PsiModifierListOwner)) return null; PsiModifierListOwner annotationOwner = getAnnotationOwner(element); - PsiAnnotation ownAnnotation = PsiBasedExternalAnnotationResolver.findOwnAnnotation(annotationOwner, KOTLIN_SIGNATURE); + PsiModifierList list = annotationOwner.getModifierList(); + PsiAnnotation ownAnnotation = list == null ? null : list.findAnnotation(KOTLIN_SIGNATURE.asString()); PsiAnnotation annotation = ownAnnotation != null ? ownAnnotation - : PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE.getFqName()); + : PsiBasedExternalAnnotationResolver.findExternalAnnotation(annotationOwner, KOTLIN_SIGNATURE); if (annotation == null) return null; if (annotation.getParameterList().getAttributes().length == 0) return null; return annotation; diff --git a/idea/src/org/jetbrains/jet/plugin/versions/KotlinAbiVersionIndex.java b/idea/src/org/jetbrains/jet/plugin/versions/KotlinAbiVersionIndex.java index aa4393848e7..8cff8817a95 100644 --- a/idea/src/org/jetbrains/jet/plugin/versions/KotlinAbiVersionIndex.java +++ b/idea/src/org/jetbrains/jet/plugin/versions/KotlinAbiVersionIndex.java @@ -16,6 +16,7 @@ package org.jetbrains.jet.plugin.versions; +import com.google.common.collect.ImmutableSet; import com.google.common.collect.Maps; import com.intellij.openapi.diagnostic.Logger; import com.intellij.openapi.fileTypes.StdFileTypes; @@ -30,9 +31,12 @@ import org.jetbrains.asm4.ClassReader; import org.jetbrains.asm4.ClassVisitor; import org.jetbrains.asm4.Opcodes; import org.jetbrains.jet.lang.resolve.java.AbiVersionUtil; -import org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames; import java.util.Map; +import java.util.Set; + +import static org.jetbrains.jet.codegen.AsmUtil.asmDescByFqNameWithoutInnerClasses; +import static org.jetbrains.jet.lang.resolve.java.JvmAnnotationNames.*; /** * Important! This is not a stub-based index. And it has its own version @@ -53,7 +57,16 @@ public class KotlinAbiVersionIndex extends ScalarIndexExtension { return file.getFileType() == StdFileTypes.CLASS; } }; + private static final DataIndexer INDEXER = new DataIndexer() { + @SuppressWarnings("deprecation") + private final Set kotlinAnnotationsDesc = new ImmutableSet.Builder() + .add(asmDescByFqNameWithoutInnerClasses(OLD_JET_CLASS_ANNOTATION)) + .add(asmDescByFqNameWithoutInnerClasses(OLD_JET_PACKAGE_CLASS_ANNOTATION)) + .add(asmDescByFqNameWithoutInnerClasses(KOTLIN_CLASS)) + .add(asmDescByFqNameWithoutInnerClasses(KOTLIN_PACKAGE)) + .build(); + @NotNull @Override public Map map(FileContent inputData) { @@ -63,20 +76,16 @@ public class KotlinAbiVersionIndex extends ScalarIndexExtension { try { ClassReader classReader = new ClassReader(inputData.getContent()); classReader.accept(new ClassVisitor(Opcodes.ASM4) { - @SuppressWarnings("deprecation") @Override public AnnotationVisitor visitAnnotation(String desc, boolean visible) { - if (!JvmAnnotationNames.OLD_JET_CLASS_ANNOTATION.getDescriptor().equals(desc) && - !JvmAnnotationNames.OLD_JET_PACKAGE_CLASS_ANNOTATION.getDescriptor().equals(desc) && - !JvmAnnotationNames.KOTLIN_CLASS.getDescriptor().equals(desc) && - !JvmAnnotationNames.KOTLIN_PACKAGE.getDescriptor().equals(desc)) { + if (!kotlinAnnotationsDesc.contains(desc)) { return null; } annotationPresent.set(true); return new AnnotationVisitor(Opcodes.ASM4) { @Override public void visit(String name, Object value) { - if (JvmAnnotationNames.ABI_VERSION_FIELD_NAME.equals(name)) { + if (ABI_VERSION_FIELD_NAME.equals(name)) { if (value instanceof Integer) { Integer abiVersion = (Integer) value; result.put(abiVersion, null);