Tests for loading enum descriptors from compiled java/kotlin code.

compiler/testData/loadJavaDescriptors/enum/expected.txt

@@ -0,0 +1,14 @@
+namespace test
+
+public final enum class test.MyEnum : jet.Enum<test.MyEnum> {
+    private final /*constructor*/ fun <init>(): test.MyEnum
+    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ fun ordinal(): jet.Int
+    public final class object test.MyEnum.<class-object-for-MyEnum> {
+        private final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>
+        public final val ANOTHER: test.MyEnum
+        public final val ENTRY: test.MyEnum
+        public final fun valueOf(/*0*/ value: jet.String): test.MyEnum
+        public final fun values(): jet.Array<test.MyEnum>
+    }
+}

compiler/testData/loadJavaDescriptors/enum/java/MyEnum.java

@@ -0,0 +1,6 @@
+package test;
+
+public enum MyEnum {
+    ENTRY,
+    ANOTHER;
+}

compiler/testData/loadKotlinDescriptors/enum/simpleEnum.kt

@@ -0,0 +1,5 @@
+package test
+
+enum class MyEnum {
+  ENTRY
+}

compiler/testData/loadKotlinDescriptors/enum/simpleEnum.txt

@@ -0,0 +1,13 @@
+namespace test
+
+internal final enum class test.MyEnum : jet.Enum<test.MyEnum> {
+    public final /*constructor*/ fun <init>(/*0*/ p0: jet.String?, /*1*/ p1: jet.Int): test.MyEnum
+    public final override /*1*/ fun name(): jet.String
+    public final override /*1*/ fun ordinal(): jet.Int
+    internal final class object test.MyEnum.<class-object-for-MyEnum> {
+        public final /*constructor*/ fun <init>(): test.MyEnum.<class-object-for-MyEnum>
+        public open val ENTRY: test.MyEnum
+        public final fun valueOf(/*0*/ value: jet.String): test.MyEnum
+        public final fun values(): jet.Array<test.MyEnum>
+    }
+}

compiler/tests/org/jetbrains/jet/jvm/compiler/AbstractReadJavaBinaryClassTest.java

@@ -56,7 +56,7 @@ public abstract class AbstractReadJavaBinaryClassTest extends TestCaseWithTmpdir
         File ktFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".kt"));
         File txtFile = new File(javaFile.getPath().replaceFirst("\\.java$", ".txt"));
         NamespaceDescriptor nsa = compileKotlin(ktFile);
-        NamespaceDescriptor nsb = LoadJavaDescriptorUtil.compileJava(Collections.singletonList(javaFile), tmpdir, myTestRootDisposable);
+        NamespaceDescriptor nsb = LoadDescriptorUtil.compileJava(Collections.singletonList(javaFile), tmpdir, myTestRootDisposable);
         NamespaceComparator.compareNamespaces(nsa, nsb, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, txtFile);
     }
 

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadDescriptorUtil.java

@@ -17,15 +17,25 @@
 package org.jetbrains.jet.jvm.compiler;
 
 import com.intellij.openapi.Disposable;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.io.FileUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.CompileCompilerDependenciesTest;
 import org.jetbrains.jet.ConfigurationKind;
 import org.jetbrains.jet.JetTestUtils;
 import org.jetbrains.jet.TestJdkKind;
+import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
 import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.GenerationUtils;
+import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
 import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
 import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
 import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lang.resolve.BindingContext;
 import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
 import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
 import org.jetbrains.jet.lang.resolve.name.FqName;
@@ -44,8 +54,30 @@ import java.util.Locale;
 /**
  * @author Pavel Talanov
  */
-public final class LoadJavaDescriptorUtil {
+public final class LoadDescriptorUtil {
-    private LoadJavaDescriptorUtil() {
+    private LoadDescriptorUtil() {
+    }
+
+    @NotNull
+    public static NamespaceDescriptor compileKotlin(@NotNull File kotlinFile, File tmpdir, Disposable disposable)
+            throws IOException {
+        JetCoreEnvironment jetCoreEnvironment = JetTestUtils.createEnvironmentWithMockJdkAndIdeaAnnotations(disposable, ConfigurationKind.JDK_ONLY);
+        JetFile psiFile = JetPsiFactory.createFile(jetCoreEnvironment.getProject(), FileUtil.loadFile(kotlinFile, true));
+        GenerationState state = GenerationUtils.compileFileGetGenerationStateForTest(psiFile);
+        ClassFileFactory classFileFactory = state.getFactory();
+        CompileEnvironmentUtil.writeToOutputDirectory(classFileFactory, tmpdir);
+        NamespaceDescriptor namespaceFromSource = state.getBindingContext().get(BindingContext.FILE_TO_NAMESPACE, psiFile);
+        Assert.assertEquals("test", namespaceFromSource.getName().getName());
+        Disposer.dispose(disposable);
+
+        jetCoreEnvironment = new JetCoreEnvironment(disposable, CompileCompilerDependenciesTest.compilerConfigurationForTests(
+                ConfigurationKind.JDK_ONLY, TestJdkKind.MOCK_JDK, JetTestUtils.getAnnotationsJar(), tmpdir,
+                ForTestCompileRuntime.runtimeJarForTests()));
+
+        InjectorForJavaSemanticServices injector = new InjectorForJavaSemanticServices(BuiltinsScopeExtensionMode.ALL,
+                                                                                       jetCoreEnvironment.getProject());
+        JavaDescriptorResolver javaDescriptorResolver = injector.getJavaDescriptorResolver();
+        return javaDescriptorResolver.resolveNamespace(FqName.topLevel(Name.identifier("test")), DescriptorSearchRule.ERROR_IF_FOUND_IN_KOTLIN);
     }
     
     @NotNull

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadJavaDescriptorsTest.java

@@ -51,7 +51,7 @@ public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment {
         });
         File expected = new File(expectedFileName);
         File tmpDir = JetTestUtils.tmpDir(expected.getName());
-        NamespaceDescriptor javaNamespaceDescriptor = LoadJavaDescriptorUtil.compileJava(files, tmpDir, getTestRootDisposable());
+        NamespaceDescriptor javaNamespaceDescriptor = LoadDescriptorUtil.compileJava(files, tmpDir, getTestRootDisposable());
         //NOTE: comparing namespace to file (hack)
         NamespaceComparator.compareNamespaces(javaNamespaceDescriptor, javaNamespaceDescriptor, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, expected);
     }
@@ -63,4 +63,11 @@ public final class LoadJavaDescriptorsTest extends KotlinTestWithEnvironment {
                javaDir + "/test/JFrame.java",
                javaDir + "/awt/Frame.java");
     }
+
+    public void testEnum() throws Exception {
+        String dir = PATH + "/enum";
+        String javaDir = dir + "/java";
+        doTest(dir + "/expected.txt",
+               javaDir + "/MyEnum.java");
+    }
 }

compiler/tests/org/jetbrains/jet/jvm/compiler/LoadKotlinDescriptorsTest.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright 2010-2012 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.jvm.compiler;
+
+import com.google.common.base.Function;
+import com.google.common.collect.Collections2;
+import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.io.FileUtil;
+import junit.framework.Assert;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.jet.CompileCompilerDependenciesTest;
+import org.jetbrains.jet.ConfigurationKind;
+import org.jetbrains.jet.JetTestUtils;
+import org.jetbrains.jet.TestJdkKind;
+import org.jetbrains.jet.cli.jvm.compiler.CompileEnvironmentUtil;
+import org.jetbrains.jet.cli.jvm.compiler.JetCoreEnvironment;
+import org.jetbrains.jet.codegen.ClassFileFactory;
+import org.jetbrains.jet.codegen.GenerationState;
+import org.jetbrains.jet.codegen.GenerationUtils;
+import org.jetbrains.jet.codegen.forTestCompile.ForTestCompileRuntime;
+import org.jetbrains.jet.di.InjectorForJavaSemanticServices;
+import org.jetbrains.jet.lang.BuiltinsScopeExtensionMode;
+import org.jetbrains.jet.lang.descriptors.NamespaceDescriptor;
+import org.jetbrains.jet.lang.psi.JetFile;
+import org.jetbrains.jet.lang.psi.JetPsiFactory;
+import org.jetbrains.jet.lang.resolve.BindingContext;
+import org.jetbrains.jet.lang.resolve.java.DescriptorSearchRule;
+import org.jetbrains.jet.lang.resolve.java.JavaDescriptorResolver;
+import org.jetbrains.jet.lang.resolve.name.FqName;
+import org.jetbrains.jet.lang.resolve.name.Name;
+import org.jetbrains.jet.test.TestCaseWithTmpdir;
+import org.jetbrains.jet.test.util.NamespaceComparator;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.Collection;
+
+/**
+ * @author Pavel Talanov
+ */
+public final class LoadKotlinDescriptorsTest extends TestCaseWithTmpdir {
+    @NotNull
+    private final String PATH = "compiler/testData/loadKotlinDescriptors";
+
+    private void doTest(@NotNull String expectedFileName, @NotNull String kotlinFileName) throws Exception {
+        NamespaceDescriptor namespaceFromClass = LoadDescriptorUtil.compileKotlin(new File(kotlinFileName), tmpdir, myTestRootDisposable);
+
+        NamespaceComparator.compareNamespaces(namespaceFromClass, namespaceFromClass, NamespaceComparator.DONT_INCLUDE_METHODS_OF_OBJECT, new File(expectedFileName));
+    }
+
+    public void testSimpleEnum() throws Exception {
+        String dir = PATH + "/enum";
+        doTest(dir + "/simpleEnum.txt",
+               dir + "/simpleEnum.kt");
+    }
+}