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) {
-            is JavaFieldImpl -> JavaConstantExpressionEvaluator.computeConstantExpression(field.initializer, false)
-            is BinaryJavaField -> field.compiledValue
-            else -> null
-        } ?: return null
+        val evaluated = field.initializerValue ?: 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() {
-        return getPsi().getInitializer();
+    @Override
+    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(