Add JetPackageClass annotation

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

@@ -34,6 +34,7 @@ import org.jetbrains.jet.lang.diagnostics.DiagnosticUtils;
 import org.jetbrains.jet.lang.psi.*;
 import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.JvmClassName;
+import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
 import org.jetbrains.jet.lang.resolve.java.PackageClassUtils;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
@@ -84,6 +85,10 @@ public class NamespaceCodegen extends MemberCodegen {
     public void generate(CompilationErrorHandler errorHandler) {
         boolean multiFile = CodegenBinding.isMultiFileNamespace(state.getBindingContext(), name);
 
+        if (shouldGenerateNSClass(files)) {
+            v.getClassBuilder().newAnnotation(JvmStdlibNames.JET_PACKAGE_CLASS.getDescriptor(), true);
+        }
+
         for (JetFile file : files) {
             VirtualFile vFile = file.getVirtualFile();
             try {

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

@@ -46,7 +46,8 @@ public final class DescriptorResolverUtils {
     }
 
     public static boolean isKotlinClass(@NotNull PsiClass psiClass) {
-        return new PsiClassWrapper(psiClass).getJetClass().isDefined() || PackageClassUtils.isPackageClass(psiClass);
+        PsiClassWrapper wrapper = new PsiClassWrapper(psiClass);
+        return wrapper.getJetClass().isDefined() ||  wrapper.getJetPackageClass().isDefined();
     }
 
     public static boolean isInnerEnum(@NotNull PsiClass innerClass, @Nullable DeclarationDescriptor owner) {

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

@@ -68,7 +68,9 @@ public class JvmStdlibNames {
 
 
     public static final JvmClassName JET_CLASS = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetClass");
-    
+
+    public static final JvmClassName JET_PACKAGE_CLASS = JvmClassName.byFqNameWithoutInnerClasses("jet.runtime.typeinfo.JetPackageClass");
+
     public static final String JET_CLASS_SIGNATURE = "signature";
 
 

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

@@ -19,6 +19,7 @@ package org.jetbrains.jet.lang.resolve.java;
 import com.intellij.openapi.util.text.StringUtil;
 import com.intellij.psi.PsiClass;
 import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
 import org.jetbrains.jet.lang.resolve.name.FqName;
 import org.jetbrains.jet.lang.resolve.name.Name;
 
@@ -38,21 +39,7 @@ public class PackageClassUtils {
         return packageFQN.child(Name.identifier(getPackageClassName(packageFQN)));
     }
 
-    public static boolean isPackageClass(@NotNull FqName fqName) {
-        if (fqName.isRoot()) {
-            return true;
-        }
-        return getPackageClassName(fqName.parent()).equals(fqName.shortName().getName());
-    }
-
     public static boolean isPackageClass(@NotNull PsiClass psiClass) {
-        String qualifiedName = psiClass.getQualifiedName();
-        if (qualifiedName == null) {
-            return false;
-        }
-        if (DEFAULT_PACKAGE.equals(qualifiedName)) {
-            return true;
-        }
-        return getPackageClassName(new FqName(qualifiedName).parent()).equals(psiClass.getName());
+        return JetPackageClassAnnotation.get(psiClass).isDefined();
     }
 }

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/kt/JetPackageClassAnnotation.java

@@ -0,0 +1,42 @@
+/*
+ * 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 org.jetbrains.jet.lang.resolve.java.kt;
+
+import com.intellij.psi.PsiAnnotation;
+import com.intellij.psi.PsiClass;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jet.lang.resolve.java.JvmStdlibNames;
+import org.jetbrains.jet.lang.resolve.java.resolver.JavaAnnotationResolver;
+
+public class JetPackageClassAnnotation extends PsiAnnotationWithFlags {
+    private static final JetPackageClassAnnotation NULL_ANNOTATION = new JetPackageClassAnnotation(null);
+    static {
+        NULL_ANNOTATION.checkInitialized();
+    }
+
+    private JetPackageClassAnnotation(@Nullable PsiAnnotation psiAnnotation) {
+        super(psiAnnotation);
+    }
+
+    @NotNull
+    public static JetPackageClassAnnotation get(PsiClass psiClass) {
+        final PsiAnnotation annotation = JavaAnnotationResolver.findOwnAnnotation(psiClass,
+                                                                                  JvmStdlibNames.JET_PACKAGE_CLASS.getFqName().getFqName());
+        return annotation != null ? new JetPackageClassAnnotation(annotation) : NULL_ANNOTATION;
+    }
+}

compiler/frontend.java/src/org/jetbrains/jet/lang/resolve/java/wrapper/PsiClassWrapper.java

@@ -17,13 +17,9 @@
 package org.jetbrains.jet.lang.resolve.java.wrapper;
 
 import com.intellij.psi.PsiClass;
-import com.intellij.psi.PsiField;
-import com.intellij.psi.PsiMethod;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.resolve.java.kt.JetClassAnnotation;
-
-import java.util.ArrayList;
-import java.util.List;
+import org.jetbrains.jet.lang.resolve.java.kt.JetPackageClassAnnotation;
 
 public class PsiClassWrapper {
 
@@ -44,6 +40,8 @@ public class PsiClassWrapper {
     }
     
     private JetClassAnnotation jetClass;
+    private JetPackageClassAnnotation jetPackageClass;
+
     @NotNull
     public JetClassAnnotation getJetClass() {
         if (jetClass == null) {
@@ -51,4 +49,12 @@ public class PsiClassWrapper {
         }
         return jetClass;
     }
+
+    @NotNull
+    public JetPackageClassAnnotation getJetPackageClass() {
+        if (jetPackageClass == null) {
+            jetPackageClass = JetPackageClassAnnotation.get(psiClass);
+        }
+        return jetPackageClass;
+    }
 }

compiler/tests/org/jetbrains/jet/PackageClassNameTest.java

@@ -57,36 +57,6 @@ public class PackageClassNameTest {
         doTest(FqName.ROOT.child(Name.identifier("kotlin")), "KotlinPackage", "_DefaultPackage");
     }
 
-    @Test
-    public void testIsPackageClass1() {
-        doTestIsPackageClass("", true);
-    }
-
-    @Test
-    public void testIsPackageClass2() {
-        doTestIsPackageClass("kotlin", false);
-    }
-
-    @Test
-    public void testIsPackageClass3() {
-        doTestIsPackageClass("kotlin.KotlinPackage", true);
-    }
-
-    @Test
-    public void testIsPackageClass4() {
-        doTestIsPackageClass("kotlin.test.SomeClass", false);
-    }
-
-    @Test
-    public void testIsPackageClass5() {
-        doTestIsPackageClass("kotlin.io.IoPackage", true);
-    }
-
-    @Test
-    public void testInnerIsPackage() {
-        doTestIsPackageClass("kotlin.io.IoPackage$Foo", false);
-    }
-
     private void doTest(@NotNull String name, @NotNull String expectedForChild, @Nullable String expectedForParent) {
         doTest(new FqName(name), expectedForChild, expectedForParent);
     }
@@ -97,8 +67,4 @@ public class PackageClassNameTest {
             assertEquals("Wrong result for parent [" + name + "].", expectedForParent, getPackageClassName(name.parent()));
         }
     }
-
-    private void doTestIsPackageClass(String testedName, boolean expected) {
-        assertEquals("Wrong result for [" + testedName + "].", expected, isPackageClass(new FqName(testedName)));
-    }
 }