Split KotlinInfo annotation into two: KotlinClass and KotlinPackage

Two annotations are needed to properly distinguish package classes

compiler/backend/src/org/jetbrains/jet/codegen/ImplementationBodyCodegen.java

@@ -226,7 +226,7 @@ public class ImplementationBodyCodegen extends ClassBodyCodegen {
 
         ClassData data = new ClassData(createNameResolver(serializer.getNameTable()), classProto);
 
-        AnnotationVisitor av = v.getVisitor().visitAnnotation(JvmStdlibNames.KOTLIN_INFO_CLASS.getDescriptor(), true);
+        AnnotationVisitor av = v.getVisitor().visitAnnotation(JvmStdlibNames.KOTLIN_CLASS.getDescriptor(), true);
         av.visit(JvmStdlibNames.ABI_VERSION_NAME, JvmAbi.VERSION);
         AnnotationVisitor array = av.visitArray(JvmStdlibNames.KOTLIN_INFO_DATA_FIELD);
         for (String string : JavaProtoBufUtil.encodeBytes(data.toBytes())) {

compiler/backend/src/org/jetbrains/jet/codegen/NamespaceCodegen.java

@@ -129,12 +129,12 @@ public class NamespaceCodegen extends MemberCodegen {
             }
         }
 
-        writeKotlinInfoIfNeeded(MemberMap.union(namespaceMembers));
+        writeKotlinPackageAnnotationIfNeeded(MemberMap.union(namespaceMembers));
 
         assert v.isActivated() == shouldGenerateNSClass(files) : "Different algorithms for generating namespace class and for heuristics";
     }
 
-    private void writeKotlinInfoIfNeeded(@NotNull MemberMap members) {
+    private void writeKotlinPackageAnnotationIfNeeded(@NotNull MemberMap members) {
         DescriptorSerializer serializer = new DescriptorSerializer(new JavaSerializerExtension(members));
         ProtoBuf.Package.Builder packageProto = ProtoBuf.Package.newBuilder();
         boolean writeAnnotation = false;
@@ -168,7 +168,7 @@ public class NamespaceCodegen extends MemberCodegen {
 
         PackageData data = new PackageData(createNameResolver(serializer.getNameTable()), packageProto.build());
 
-        AnnotationVisitor av = v.getClassBuilder().newAnnotation(JvmStdlibNames.KOTLIN_INFO_CLASS.getDescriptor(), true);
+        AnnotationVisitor av = v.getClassBuilder().newAnnotation(JvmStdlibNames.KOTLIN_PACKAGE.getDescriptor(), true);
         av.visit(JvmStdlibNames.ABI_VERSION_NAME, JvmAbi.VERSION);
         AnnotationVisitor array = av.visitArray(JvmStdlibNames.KOTLIN_INFO_DATA_FIELD);
         for (String string : JavaProtoBufUtil.encodeBytes(data.toBytes())) {

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

@@ -24,7 +24,6 @@ import org.jetbrains.jet.lang.descriptors.*;
 import org.jetbrains.jet.lang.descriptors.annotations.AnnotationDescriptor;
 import org.jetbrains.jet.lang.resolve.constants.StringValue;
 import org.jetbrains.jet.lang.resolve.java.kt.PsiAnnotationWithFlags;
-import org.jetbrains.jet.lang.resolve.java.wrapper.PsiClassWrapper;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMemberWrapper;
 import org.jetbrains.jet.lang.resolve.java.wrapper.PsiMethodWrapper;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -46,9 +45,14 @@ public final class DescriptorResolverUtils {
     private DescriptorResolverUtils() {
     }
 
+    //TODO: check that method is used properly
     public static boolean isKotlinClass(@NotNull PsiClass psiClass) {
-        PsiClassWrapper wrapper = new PsiClassWrapper(psiClass);
+        PsiModifierList modifierList = psiClass.getModifierList();
-        return wrapper.getJetClass().isDefined() ||  wrapper.getJetPackageClass().isDefined();
+        if (modifierList == null) {
+            return false;
+        }
+        PsiAnnotation kotlinClassAnnotation = modifierList.findAnnotation(JvmStdlibNames.KOTLIN_CLASS.getFqName().asString());
+        return kotlinClassAnnotation != null;
     }
 
     @NotNull

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

@@ -16,7 +16,8 @@
 
 package org.jetbrains.jet.lang.resolve.java;
 
-import jet.KotlinInfo;
+import jet.KotlinClass;
+import jet.KotlinPackage;
 import jet.runtime.typeinfo.JetConstructor;
 
 public class JvmStdlibNames {
@@ -69,7 +70,9 @@ public class JvmStdlibNames {
      */
     public static final String JET_CONSTRUCTOR_HIDDEN_FIELD = "hidden";
 
-    public static final JvmClassName KOTLIN_INFO_CLASS = JvmClassName.byFqNameWithoutInnerClasses(KotlinInfo.class.getCanonicalName());
+    public static final JvmClassName KOTLIN_CLASS = JvmClassName.byFqNameWithoutInnerClasses(KotlinClass.class.getCanonicalName());
+
+    public static final JvmClassName KOTLIN_PACKAGE = JvmClassName.byFqNameWithoutInnerClasses(KotlinPackage.class.getCanonicalName());
 
     public static final JvmClassName JET_CLASS = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetClass");
 

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/AnnotationDescriptorDeserializer.java

@@ -33,10 +33,7 @@ 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.CompileTimeConstant;
-import org.jetbrains.jet.lang.resolve.java.DescriptorResolverUtils;
+import org.jetbrains.jet.lang.resolve.java.*;
-import org.jetbrains.jet.lang.resolve.java.JvmAbi;
-import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
-import org.jetbrains.jet.lang.resolve.java.PsiClassFinder;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 import org.jetbrains.jet.utils.ExceptionUtils;
@@ -133,7 +130,9 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
 
     private static boolean ignoreAnnotation(@NotNull String desc) {
         // TODO: JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION ?
-        return desc.equals(DeserializedDescriptorResolver.KOTLIN_INFO_TYPE) || desc.startsWith("Ljet/runtime/typeinfo/");
+        return desc.equals(JvmStdlibNames.KOTLIN_CLASS.getDescriptor())
+               || desc.equals(JvmStdlibNames.KOTLIN_PACKAGE.getDescriptor())
+               || desc.startsWith("Ljet/runtime/typeinfo/");
     }
 
     @NotNull
@@ -223,7 +222,8 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
 
     @NotNull
     private Map<MemberSignature, List<AnnotationDescriptor>> loadMemberAnnotationsFromFile(@NotNull VirtualFile file) throws IOException {
-        final Map<MemberSignature, List<AnnotationDescriptor>> memberAnnotations = new HashMap<MemberSignature, List<AnnotationDescriptor>>();
+        final Map<MemberSignature, List<AnnotationDescriptor>> memberAnnotations =
+                new HashMap<MemberSignature, List<AnnotationDescriptor>>();
 
         new ClassReader(file.getInputStream()).accept(new ClassVisitor(Opcodes.ASM4) {
             @Override
@@ -291,7 +291,9 @@ public class AnnotationDescriptorDeserializer implements AnnotationDeserializer
             else if (syntheticMethodName != null) {
                 return fromMethodNameAndDesc(syntheticMethodName, JvmAbi.ANNOTATED_PROPERTY_METHOD_SIGNATURE);
             }
-            else return null;
+            else {
+                return null;
+            }
         }
 
         @Nullable

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/DeserializedDescriptorResolver.java

@@ -51,7 +51,6 @@ import static org.jetbrains.jet.lang.resolve.java.resolver.DeserializedResolverU
 import static org.jetbrains.jet.lang.resolve.java.resolver.DeserializedResolverUtils.kotlinFqNameToJavaFqName;
 
 public final class DeserializedDescriptorResolver {
-    public static final String KOTLIN_INFO_TYPE = JvmStdlibNames.KOTLIN_INFO_CLASS.getAsmType().toString();
 
     private AnnotationDescriptorDeserializer annotationDeserializer;
 
@@ -140,8 +139,7 @@ public final class DeserializedDescriptorResolver {
 
         DeclarationDescriptor owner = classId.isTopLevelClass()
                                       ? javaNamespaceResolver.resolveNamespace(classId.getPackageFqName(), INCLUDE_KOTLIN)
-                                      : javaClassResolver
+                                      : javaClassResolver.resolveClass(kotlinFqNameToJavaFqName(classId.getOuterClassId().asSingleFqName()));
-                                              .resolveClass(kotlinFqNameToJavaFqName(classId.getOuterClassId().asSingleFqName()));
         assert owner != null : "No owner found for " + classId;
 
         return new DeserializedClassDescriptor(classId, storageManager, owner, classData.getNameResolver(),
@@ -204,8 +202,9 @@ public final class DeserializedDescriptorResolver {
         private String[] data = null;
 
         @Override
-        public AnnotationVisitor visitAnnotation(String desc, boolean visible) {
+        public AnnotationVisitor visitAnnotation(final String desc, boolean visible) {
-            if (!desc.equals(KOTLIN_INFO_TYPE)) {
+            if (!desc.equals(JvmStdlibNames.KOTLIN_CLASS.getDescriptor()) &&
+                !desc.equals(JvmStdlibNames.KOTLIN_PACKAGE.getDescriptor())) {
                 return null;
             }
 
@@ -216,7 +215,7 @@ public final class DeserializedDescriptorResolver {
                         version = (Integer) value;
                     }
                     else if (isAbiVersionCompatible(version)) {
-                        throw new IllegalStateException("Unexpected argument " + name + " for annotation " + KOTLIN_INFO_TYPE);
+                        throw new IllegalStateException("Unexpected argument " + name + " for annotation " + desc);
                     }
                 }
 
@@ -226,7 +225,7 @@ public final class DeserializedDescriptorResolver {
                         return stringArrayVisitor();
                     }
                     else if (isAbiVersionCompatible(version)) {
-                        throw new IllegalStateException("Unexpected array argument " + name + " for annotation " + KOTLIN_INFO_TYPE);
+                        throw new IllegalStateException("Unexpected array argument " + name + " for annotation " + desc);
                     }
 
                     return super.visitArray(name);

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaAnnotationResolver.java

@@ -83,7 +83,8 @@ public final class JavaAnnotationResolver {
         // Don't process internal jet annotations and jetbrains NotNull annotations
         if (qname.startsWith("jet.runtime.typeinfo.")
             || qname.equals(JvmAbi.JETBRAINS_NOT_NULL_ANNOTATION.getFqName().asString())
-            || qname.equals(JvmStdlibNames.KOTLIN_INFO_CLASS.getFqName().asString())
+            || qname.equals(JvmStdlibNames.KOTLIN_CLASS.getFqName().asString())
+            || qname.equals(JvmStdlibNames.KOTLIN_PACKAGE.getFqName().asString())
         ) {
             return null;
         }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/resolver/JavaNamespaceResolver.java

@@ -166,14 +166,14 @@ public final class JavaNamespaceResolver {
             trace.record(JavaBindingContext.JAVA_NAMESPACE_KIND, namespaceDescriptor, JavaNamespaceKind.PROPER);
 
             if (psiClass != null) {
-                boolean compiledKotlinClass = isCompiledKotlinClass(psiClass);
+                boolean hasKotlinPackageAnnotation = hasKotlinPackageAnnotation(psiClass);
-                if (isOldKotlinPackageClass(psiClass) && !compiledKotlinClass) {
+                if (isOldKotlinPackageClass(psiClass) && !hasKotlinPackageAnnotation) {
-                    // If psiClass has old annotations (@JetPackage) but doesn't have @KotlinInfo, report ABI version error
+                    // If psiClass has old annotations (@JetPackage) but doesn't have @KotlinPackage, report ABI version error
                     AbiVersionUtil.checkAbiVersion(psiClass, INVALID_VERSION, trace);
                 }
-                if (compiledKotlinClass) {
+                if (hasKotlinPackageAnnotation) {
-                    // If psiClass has @KotlinInfo (regardless of whether it has @JetPackage or not), deserialize it to Kotlin descriptor.
+                    // If psiClass has @KotlinPackage (regardless of whether it has @JetPackage or not), deserialize it to Kotlin descriptor.
-                    // Note that @KotlinInfo may still have an old ABI version, in which case null is returned by createKotlinPackageScope
+                    // Note that @KotlinPackage may still have an old ABI version, in which case null is returned by createKotlinPackageScope
                     JetScope kotlinPackageScope = deserializedDescriptorResolver.createKotlinPackageScope(psiClass, namespaceDescriptor);
                     if (kotlinPackageScope != null) return kotlinPackageScope;
                 }
@@ -205,15 +205,20 @@ public final class JavaNamespaceResolver {
         return new PsiClassWrapper(psiClass).getJetPackageClass().isDefined();
     }
 
-    private static boolean isCompiledKotlinClass(@NotNull PsiClass psiClass) {
+    private static boolean hasKotlinPackageAnnotation(@NotNull PsiClass psiClass) {
         // TODO: merge this method with DescriptorResolverUtils#isKotlinClass
         // NOTE: we need to check against ClsClassImpl because it can be a Java source, pretending to be a Kotlin class.
         // In that case we can't really read the annotation from psiClass's virtual file
-        if (psiClass instanceof ClsClassImpl) {
+        if (!(psiClass instanceof ClsClassImpl)) {
-            PsiModifierList list = psiClass.getModifierList();
+            return false;
-            if (list != null) {
+        }
-                return list.findAnnotation(JvmStdlibNames.KOTLIN_INFO_CLASS.getFqName().asString()) != null;
+        return hasAnnotation(psiClass, JvmStdlibNames.KOTLIN_PACKAGE.getFqName());
-            }
+    }
+
+    private static boolean hasAnnotation(@NotNull PsiClass psiClass, @NotNull FqName annotationFqName) {
+        PsiModifierList list = psiClass.getModifierList();
+        if (list != null) {
+            return list.findAnnotation(annotationFqName.asString()) != null;
         }
         return false;
     }

compiler/tests/org/jetbrains/jet/codegen/KotlinClassAnnotationTest.java

@@ -14,14 +14,17 @@
  * limitations under the License.
  */
 
-package org.jetbrains.jet.descriptors.serialization;
+package org.jetbrains.jet.codegen;
 
-import jet.KotlinInfo;
+import jet.KotlinClass;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
-import org.jetbrains.jet.codegen.CodegenTestCase;
+import org.jetbrains.jet.descriptors.serialization.AbstractDescriptorFinder;
+import org.jetbrains.jet.descriptors.serialization.ClassData;
+import org.jetbrains.jet.descriptors.serialization.ClassId;
+import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
 import org.jetbrains.jet.descriptors.serialization.descriptors.AnnotationDeserializer;
 import org.jetbrains.jet.lang.descriptors.ClassDescriptor;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
@@ -32,7 +35,7 @@ import org.jetbrains.jet.lang.resolve.name.FqNameUnsafe;
 
 import java.io.IOException;
 
-public class KotlinInfoForClassTest extends CodegenTestCase {
+public class KotlinClassAnnotationTest extends CodegenTestCase {
     public static final FqName NAMESPACE_NAME = new FqName("test");
     public static final FqNameUnsafe CLASS_NAME = new FqNameUnsafe("A");
 
@@ -51,10 +54,10 @@ public class KotlinInfoForClassTest extends CodegenTestCase {
                  "}\n");
         Class aClass = generateClass(NAMESPACE_NAME + "." + CLASS_NAME);
 
-        assertTrue(aClass.isAnnotationPresent(KotlinInfo.class));
+        assertTrue(aClass.isAnnotationPresent(KotlinClass.class));
-        KotlinInfo kotlinInfo = (KotlinInfo) aClass.getAnnotation(KotlinInfo.class);
+        KotlinClass kotlinClass = (KotlinClass) aClass.getAnnotation(KotlinClass.class);
 
-        AbstractDescriptorFinder descriptorFinder = new KotlinInfoBasedDescriptorFinder(kotlinInfo);
+        AbstractDescriptorFinder descriptorFinder = new KotlinInfoBasedDescriptorFinder(kotlinClass);
 
         ClassDescriptor descriptor = descriptorFinder.findClass(new ClassId(NAMESPACE_NAME, CLASS_NAME));
         assertNotNull(descriptor);
@@ -65,10 +68,10 @@ public class KotlinInfoForClassTest extends CodegenTestCase {
         private final ClassData classData;
         private final NamespaceDescriptorImpl namespace;
 
-        public KotlinInfoBasedDescriptorFinder(@NotNull KotlinInfo kotlinInfo) throws IOException {
+        public KotlinInfoBasedDescriptorFinder(@NotNull KotlinClass kotlinClass) throws IOException {
             super(new LockBasedStorageManager(), AnnotationDeserializer.UNSUPPORTED);
 
-            this.classData = JavaProtoBufUtil.readClassDataFrom(kotlinInfo.data());
+            this.classData = JavaProtoBufUtil.readClassDataFrom(kotlinClass.data());
             this.namespace = JetTestUtils.createTestNamespace(NAMESPACE_NAME.shortName());
         }
 

compiler/tests/org/jetbrains/jet/codegen/KotlinPackageAnnotationTest.java

@@ -16,7 +16,7 @@
 
 package org.jetbrains.jet.codegen;
 
-import jet.KotlinInfo;
+import jet.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.descriptors.serialization.JavaProtoBufUtil;
@@ -30,7 +30,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public class KotlinInfoForPackageTest extends CodegenTestCase {
+public class KotlinPackageAnnotationTest extends CodegenTestCase {
     public static final FqName NAMESPACE_NAME = new FqName("test");
 
     @Override
@@ -50,10 +50,10 @@ public class KotlinInfoForPackageTest extends CodegenTestCase {
                  "object C\n");
         Class aClass = generateClass(PackageClassUtils.getPackageClassFqName(NAMESPACE_NAME).asString());
 
-        assertTrue(aClass.isAnnotationPresent(KotlinInfo.class));
+        assertTrue(aClass.isAnnotationPresent(KotlinPackage.class));
-        KotlinInfo kotlinInfo = (KotlinInfo) aClass.getAnnotation(KotlinInfo.class);
+        KotlinPackage kotlinPackage = (KotlinPackage) aClass.getAnnotation(KotlinPackage.class);
 
-        PackageData data = JavaProtoBufUtil.readPackageDataFrom(kotlinInfo.data());
+        PackageData data = JavaProtoBufUtil.readPackageDataFrom(kotlinPackage.data());
 
         Set<String> classNames = collectClassNames(data);
         assertSameElements(Arrays.asList("A", "B", "C"), classNames);

runtime/src/jet/KotlinClass.java

@@ -20,7 +20,7 @@ import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 
 @Retention(RetentionPolicy.RUNTIME)
-public @interface KotlinInfo {
+public @interface KotlinClass {
     int abiVersion();
 
     String[] data();

runtime/src/jet/KotlinPackage.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2010-2013 JetBrains s.r.o.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package jet;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+@Retention(RetentionPolicy.RUNTIME)
+public @interface KotlinPackage {
+    int abiVersion();
+
+    String[] data();
+}