Light Classes: Provide light classes (as well as light fields) for enum entries

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightClassForEnumEntry.kt

@@ -0,0 +1,32 @@
+/*
+ * 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.asJava
+
+import com.intellij.psi.PsiManager
+import org.jetbrains.jet.lang.resolve.name.FqName
+import org.jetbrains.jet.lang.psi.JetEnumEntry
+import com.intellij.psi.PsiEnumConstantInitializer
+import com.intellij.psi.PsiEnumConstant
+
+public class KotlinLightClassForEnumEntry(
+        psiManager: PsiManager,
+        fqName: FqName,
+        enumEntry: JetEnumEntry,
+        private val enumConstant: PsiEnumConstant
+): KotlinLightClassForAnonymousDeclaration(psiManager, fqName, enumEntry), PsiEnumConstantInitializer {
+    override fun getEnumConstant(): PsiEnumConstant = enumConstant
+}

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinLightEnumConstant.kt

@@ -23,15 +23,17 @@ class KotlinLightEnumConstant(
         manager: PsiManager,
         origin: JetEnumEntry,
         enumConstant: PsiEnumConstant,
-        containingClass: PsiClass
+        containingClass: PsiClass,
+        private val initializingClass: PsiEnumConstantInitializer?
 ) : KotlinLightField<JetEnumEntry, PsiEnumConstant>(manager, origin, enumConstant, containingClass), PsiEnumConstant {
-    override fun copy() = KotlinLightEnumConstant(getManager()!!, getOrigin(), getDelegate(), getContainingClass()!!)
+    override fun copy() = KotlinLightEnumConstant(getManager()!!, getOrigin(), getDelegate(), getContainingClass()!!, initializingClass)
 
     // NOTE: we don't use "delegation by" because the compiler would generate method calls to ALL of PsiEnumConstant members,
     // but we need only members whose implementations are not present in KotlinLightField
     override fun getArgumentList(): PsiExpressionList? = getDelegate().getArgumentList()
-    override fun getInitializingClass(): PsiEnumConstantInitializer? = getDelegate().getInitializingClass()
-    override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer = getDelegate().getOrCreateInitializingClass()
+    override fun getInitializingClass(): PsiEnumConstantInitializer? = initializingClass
+    override fun getOrCreateInitializingClass(): PsiEnumConstantInitializer =
+            initializingClass ?: throw UnsupportedOperationException("Can't create enum constant body: ${getDelegate().getName()}")
     override fun resolveConstructor(): PsiMethod? = getDelegate().resolveConstructor()
     override fun resolveMethod(): PsiMethod? = getDelegate().resolveMethod()
     override fun resolveMethodGenerics(): JavaResolveResult = getDelegate().resolveMethodGenerics()

compiler/jet.as.java.psi/src/org/jetbrains/jet/asJava/KotlinWrappingLightClass.java

@@ -32,6 +32,7 @@ import kotlin.Function1;
 import kotlin.KotlinPackage;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.jet.lang.psi.*;
+import org.jetbrains.jet.lang.resolve.name.FqName;
 
 import java.util.List;
 
@@ -104,6 +105,9 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
         return myInnersCache.findInnerClassByName(name, checkBases);
     }
 
+    /**
+     * @see org.jetbrains.jet.codegen.binding.CodegenBinding#ENUM_ENTRY_CLASS_NEED_SUBCLASS
+      */
     @NotNull
     @Override
     public List<PsiField> getOwnFields() {
@@ -114,8 +118,14 @@ public abstract class KotlinWrappingLightClass extends AbstractLightClass implem
                 if (declaration instanceof JetEnumEntry) {
                     assert field instanceof PsiEnumConstant : "Field delegate should be an enum constant (" + field.getName() + "):\n" +
                                                               JetPsiUtil.getElementTextWithContext(declaration);
-                    return new KotlinLightEnumConstant(myManager, (JetEnumEntry) declaration, ((PsiEnumConstant) field),
-                                                       KotlinWrappingLightClass.this);
+                    JetEnumEntry enumEntry = (JetEnumEntry) declaration;
+                    PsiEnumConstant enumConstant = (PsiEnumConstant) field;
+                    FqName enumConstantFqName = new FqName(getFqName().asString() + "." + enumEntry.getName());
+                    KotlinLightClassForEnumEntry initializingClass =
+                            enumEntry.getDeclarations().isEmpty()
+                            ? null
+                            : new KotlinLightClassForEnumEntry(myManager, enumConstantFqName, enumEntry, enumConstant);
+                    return new KotlinLightEnumConstant(myManager, enumEntry, enumConstant, KotlinWrappingLightClass.this, initializingClass);
                 }
                 if (declaration != null) {
                     return new KotlinLightFieldForDeclaration(myManager, declaration, field, KotlinWrappingLightClass.this);