Introduce initializer-related properties into JavaField

It's much more convenient to use and implement these
properties instead of manual "pattern matching" in the
JavaPropertyInitializerEvaluatorImpl

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/components/JavaPropertyInitializerEvaluatorImpl.kt

@@ -16,23 +16,15 @@
 
 package org.jetbrains.kotlin.load.java.components
 
-import com.intellij.psi.impl.JavaConstantExpressionEvaluator
-import com.intellij.psi.util.PsiUtil
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.load.java.structure.JavaField
-import org.jetbrains.kotlin.load.java.structure.impl.classFiles.BinaryJavaField
-import org.jetbrains.kotlin.load.java.structure.impl.JavaFieldImpl
 import org.jetbrains.kotlin.resolve.constants.ConstantValue
 import org.jetbrains.kotlin.resolve.constants.ConstantValueFactory
 import org.jetbrains.kotlin.resolve.descriptorUtil.builtIns
 
 class JavaPropertyInitializerEvaluatorImpl : JavaPropertyInitializerEvaluator {
     override fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor): ConstantValue<*>? {
-        val evaluated = when (field) {
+        val evaluated = field.initializerValue ?: return null
-            is JavaFieldImpl -> JavaConstantExpressionEvaluator.computeConstantExpression(field.initializer, false)
-            is BinaryJavaField -> field.compiledValue
-            else -> null
-        } ?: return null
 
         val factory = ConstantValueFactory(descriptor.builtIns)
         when (evaluated) {
@@ -46,14 +38,4 @@ class JavaPropertyInitializerEvaluatorImpl : JavaPropertyInitializerEvaluator {
             }
         }
     }
-
-    override fun isNotNullCompileTimeConstant(field: JavaField): Boolean {
-        if (field is BinaryJavaField) {
-            return field.compiledValue != null
-        }
-
-        // PsiUtil.isCompileTimeConstant returns false for null-initialized fields,
-        // see com.intellij.psi.util.IsConstantExpressionVisitor.visitLiteralExpression()
-        return PsiUtil.isCompileTimeConstant((field as JavaFieldImpl).psi)
-    }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/JavaFieldImpl.java

@@ -17,8 +17,9 @@
 package org.jetbrains.kotlin.load.java.structure.impl;
 
 import com.intellij.psi.PsiEnumConstant;
-import com.intellij.psi.PsiExpression;
 import com.intellij.psi.PsiField;
+import com.intellij.psi.impl.JavaConstantExpressionEvaluator;
+import com.intellij.psi.util.PsiUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.kotlin.load.java.structure.JavaField;
@@ -41,7 +42,15 @@ public class JavaFieldImpl extends JavaMemberImpl<PsiField> implements JavaField
     }
 
     @Nullable
-    public PsiExpression getInitializer() {
+    @Override
-        return getPsi().getInitializer();
+    public Object getInitializerValue() {
+        return JavaConstantExpressionEvaluator.computeConstantExpression(getPsi().getInitializer(), false);
+    }
+
+    @Override
+    public boolean getHasConstantNotNullInitializer() {
+        // PsiUtil.isCompileTimeConstant returns false for null-initialized fields,
+        // see com.intellij.psi.util.IsConstantExpressionVisitor.visitLiteralExpression()
+        return PsiUtil.isCompileTimeConstant(getPsi());
     }
 }

compiler/frontend.java/src/org/jetbrains/kotlin/load/java/structure/impl/classFiles/Other.kt

@@ -29,10 +29,13 @@ class BinaryJavaField(
         override val containingClass: JavaClass,
         override val isEnumEntry: Boolean,
         override val type: JavaType,
-        val compiledValue: Any?
+        override val initializerValue: Any?
 ) : JavaField, BinaryJavaAnnotationOwner, BinaryJavaModifierListOwner {
     override val annotations: MutableCollection<JavaAnnotation> = ContainerUtil.newSmartList()
     override val annotationsByFqName by buildLazyValueForMap()
+
+    override val hasConstantNotNullInitializer: Boolean
+        get() = initializerValue != null
 }
 
 class BinaryJavaTypeParameter(

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/components/JavaPropertyInitializerEvaluator.kt

@@ -23,11 +23,7 @@ import org.jetbrains.kotlin.resolve.constants.ConstantValue
 interface JavaPropertyInitializerEvaluator {
     fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor): ConstantValue<*>?
 
-    fun isNotNullCompileTimeConstant(field: JavaField): Boolean
-
     object DoNothing : JavaPropertyInitializerEvaluator {
         override fun getInitializerConstant(field: JavaField, descriptor: PropertyDescriptor) = null
-
-        override fun isNotNullCompileTimeConstant(field: JavaField) = false
     }
 }

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/lazy/descriptors/LazyJavaScope.kt

@@ -285,7 +285,7 @@ abstract class LazyJavaScope(protected val c: LazyJavaResolverContext) : MemberS
     private fun getPropertyType(field: JavaField, annotations: Annotations): KotlinType {
         // Fields do not have their own generic parameters.
         // Simple static constants should not have flexible types.
-        val allowFlexible = !(field.isFinalStatic && c.components.javaPropertyInitializerEvaluator.isNotNullCompileTimeConstant(field))
+        val allowFlexible = !(field.isFinalStatic && field.hasConstantNotNullInitializer)
         val propertyType = c.typeResolver.transformJavaType(
                 field.type,
                 LazyJavaTypeAttributes(TypeUsage.MEMBER_SIGNATURE_INVARIANT, annotations, allowFlexible)

core/descriptor.loader.java/src/org/jetbrains/kotlin/load/java/structure/javaElements.kt

@@ -97,6 +97,8 @@ interface JavaMethod : JavaMember, JavaTypeParameterListOwner {
 interface JavaField : JavaMember {
     val isEnumEntry: Boolean
     val type: JavaType
+    val initializerValue: Any?
+    val hasConstantNotNullInitializer: Boolean
 }
 
 interface JavaConstructor : JavaMember, JavaTypeParameterListOwner {

core/descriptors.runtime/src/org/jetbrains/kotlin/load/java/structure/reflect/ReflectJavaField.kt

@@ -25,4 +25,7 @@ class ReflectJavaField(override val member: Field) : ReflectJavaMember(), JavaFi
 
     override val type: ReflectJavaType
         get() = ReflectJavaType.create(member.genericType)
+
+    override val initializerValue get() = null
+    override val hasConstantNotNullInitializer get() = false
 }