KT-56843 [SLC] Support unsafe property initializers

analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt

@@ -5,12 +5,14 @@
 
 package org.jetbrains.kotlin.analysis.api.descriptors.components
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvider
 import org.jetbrains.kotlin.analysis.api.descriptors.KtFe10AnalysisSession
 import org.jetbrains.kotlin.analysis.api.descriptors.components.base.Fe10KtAnalysisSessionComponent
 import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtConstantValue
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.components.KtConstantEvaluationMode
+import org.jetbrains.kotlin.analysis.api.descriptors.symbols.descriptorBased.base.toKtAnnotationValue
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.descriptors.PropertyDescriptor
 import org.jetbrains.kotlin.psi.KtExpression
@@ -19,6 +21,7 @@ import org.jetbrains.kotlin.resolve.BindingContext
 import org.jetbrains.kotlin.resolve.constants.evaluate.ConstantExpressionEvaluator
 import org.jetbrains.kotlin.types.TypeUtils
 
+
 internal class KtFe10CompileTimeConstantProvider(
     override val analysisSession: KtFe10AnalysisSession
 ) : KtCompileTimeConstantProvider(), Fe10KtAnalysisSessionComponent {
@@ -38,4 +41,10 @@ internal class KtFe10CompileTimeConstantProvider(
         }
         return constant?.toConstantValue(TypeUtils.NO_EXPECTED_TYPE)?.toKtConstantValue()
     }
+
+    override fun evaluateAsAnnotationValue(expression: KtExpression): KtAnnotationValue? {
+        val bindingContext = analysisContext.analyze(expression)
+        val constant = ConstantExpressionEvaluator.getPossiblyErrorConstant(expression, bindingContext)
+        return constant?.toConstantValue(TypeUtils.NO_EXPECTED_TYPE)?.toKtAnnotationValue(analysisContext)
+    }
 }

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt

@@ -6,11 +6,14 @@
 package org.jetbrains.kotlin.analysis.api.fir.components
 
 import org.jetbrains.kotlin.KtFakeSourceElementKind
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.components.KtCompileTimeConstantProvider
 import org.jetbrains.kotlin.analysis.api.components.KtConstantEvaluationMode
 import org.jetbrains.kotlin.analysis.api.fir.KtFirAnalysisSession
+import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirAnnotationValueConverter
 import org.jetbrains.kotlin.analysis.api.fir.evaluate.FirCompileTimeConstantEvaluator
+import org.jetbrains.kotlin.analysis.api.fir.utils.asKtInitializerValue
 import org.jetbrains.kotlin.analysis.api.lifetime.KtLifetimeToken
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.getOrBuildFir
 import org.jetbrains.kotlin.analysis.low.level.api.fir.api.throwUnexpectedFirElementError
@@ -36,6 +39,11 @@ internal class KtFirCompileTimeConstantProvider(
         return evaluateFir(expression.getOrBuildFir(firResolveSession), expression, mode)
     }
 
+    override fun evaluateAsAnnotationValue(expression: KtExpression): KtAnnotationValue? =
+        (expression.getOrBuildFir(firResolveSession) as? FirExpression)?.let {
+            FirAnnotationValueConverter.toConstantValue(it, firResolveSession.useSiteFirSession)
+        }
+
     private fun evaluateFir(
         fir: FirElement?,
         sourcePsi: KtExpression,

analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt

@@ -7,6 +7,7 @@ package org.jetbrains.kotlin.analysis.api.fir.evaluate
 
 import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
+import org.jetbrains.kotlin.analysis.api.base.KtConstantValueFactory
 import org.jetbrains.kotlin.analysis.api.components.KtConstantEvaluationMode
 import org.jetbrains.kotlin.descriptors.ClassKind
 import org.jetbrains.kotlin.fir.FirSession
@@ -47,7 +48,7 @@ internal object FirAnnotationValueConverter {
         val type = (typeRef as? FirResolvedTypeRef)?.type
         val constantValue = when {
             value == null -> KtConstantValue.KtNullConstantValue(expression)
-            type == null -> return null
+            type == null -> KtConstantValueFactory.createConstantValue(value, psi as? KtElement)
             type.isBoolean -> KtConstantValue.KtBooleanConstantValue(value as Boolean, expression)
             type.isChar -> KtConstantValue.KtCharConstantValue((value as? Char) ?: (value as Number).toInt().toChar(), expression)
             type.isByte -> KtConstantValue.KtByteConstantValue((value as Number).toByte(), expression)
@@ -61,10 +62,10 @@ internal object FirAnnotationValueConverter {
             type.isString -> KtConstantValue.KtStringConstantValue(value.toString(), expression)
             type.isFloat -> KtConstantValue.KtFloatConstantValue((value as Number).toFloat(), expression)
             type.isDouble -> KtConstantValue.KtDoubleConstantValue((value as Number).toDouble(), expression)
-            else -> return null
+            else -> null
         }
 
-        return KtConstantAnnotationValue(constantValue)
+        return constantValue?.let(::KtConstantAnnotationValue)
     }
 
     private fun Collection<FirExpression>.convertVarargsExpression(

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtInitializerValue.kt

@@ -35,7 +35,7 @@ public class KtConstantInitializerValue(
  * See [KtConstantInitializerValue] for more info.
  */
 public class KtNonConstantInitializerValue(
-    override val initializerPsi: KtExpression?
+    override val initializerPsi: KtExpression?,
 ) : KtInitializerValue()
 
 /**

analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtCompileTimeConstantProvider.kt

@@ -5,6 +5,7 @@
 
 package org.jetbrains.kotlin.analysis.api.components
 
+import org.jetbrains.kotlin.analysis.api.annotations.KtAnnotationValue
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
 import org.jetbrains.kotlin.psi.KtExpression
@@ -32,9 +33,22 @@ public abstract class KtCompileTimeConstantProvider : KtAnalysisSessionComponent
         expression: KtExpression,
         mode: KtConstantEvaluationMode,
     ): KtConstantValue?
+
+    public abstract fun evaluateAsAnnotationValue(expression: KtExpression): KtAnnotationValue?
 }
 
 public interface KtCompileTimeConstantProviderMixIn : KtAnalysisSessionMixIn {
+    /**
+     * Tries to evaluate the provided expression using the specified mode.
+     * Returns a [KtConstantValue] if the expression evaluates to a compile-time constant, otherwise returns null..
+     */
     public fun KtExpression.evaluate(mode: KtConstantEvaluationMode): KtConstantValue? =
         withValidityAssertion { analysisSession.compileTimeConstantProvider.evaluate(this, mode) }
+
+    /**
+     * Returns a [KtConstantValue] if the expression evaluates to a value that can be used as an annotation parameter value,
+     * e.g. an array of constants, otherwise returns null.
+     */
+    public fun KtExpression.evaluateAsAnnotationValue(): KtAnnotationValue? =
+        withValidityAssertion { analysisSession.compileTimeConstantProvider.evaluateAsAnnotationValue(this) }
 }

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForProperty.kt

@@ -8,7 +8,7 @@ package org.jetbrains.kotlin.light.classes.symbol.fields
 import com.intellij.psi.*
 import org.jetbrains.kotlin.analysis.api.KtAnalysisSession
 import org.jetbrains.kotlin.analysis.api.KtConstantInitializerValue
-import org.jetbrains.kotlin.analysis.api.annotations.hasAnnotation
+import org.jetbrains.kotlin.analysis.api.annotations.*
 import org.jetbrains.kotlin.analysis.api.base.KtConstantValue
 import org.jetbrains.kotlin.analysis.api.symbols.KtKotlinPropertySymbol
 import org.jetbrains.kotlin.analysis.api.symbols.KtPropertySymbol
@@ -173,9 +173,31 @@ internal class SymbolLightFieldForProperty private constructor(
     }
 
     private val _initializer by lazyPub {
-        _initializerValue?.createPsiExpression(this)
+        _initializerValue?.createPsiExpression(this) ?: withPropertySymbol { propertySymbol ->
+            if (propertySymbol !is KtKotlinPropertySymbol) return@withPropertySymbol null
+            (kotlinOrigin as? KtProperty)?.initializer?.evaluateAsAnnotationValue()
+                ?.let(::toPsiExpression)
+        }
     }
 
+    private fun toPsiExpression(value: KtAnnotationValue): PsiExpression? =
+        project.withElementFactorySafe {
+            when (value) {
+                is KtConstantAnnotationValue ->
+                    value.constantValue.createPsiExpression(this@SymbolLightFieldForProperty)
+                is KtEnumEntryAnnotationValue ->
+                    value.callableId?.let { createExpressionFromText(it.asSingleFqName().asString(), this@SymbolLightFieldForProperty) }
+                is KtArrayAnnotationValue ->
+                    createExpressionFromText(
+                        value.values
+                            .map { toPsiExpression(it)?.text ?: return@withElementFactorySafe null }
+                            .joinToString(", ", "{", "}"),
+                        this@SymbolLightFieldForProperty
+                    )
+                else -> null
+            }
+        }
+
     override fun getInitializer(): PsiExpression? = _initializer
 
     private val _constantValue by lazyPub {

analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt

@@ -151,17 +151,20 @@ internal fun KtType.isClassTypeWithClassId(classId: ClassId): Boolean {
     return this.classId == classId
 }
 
-private fun escapeString(str: String): String = buildString {
+private fun escapeString(s: String): String = buildString {
-    str.forEach { char ->
+    s.forEach {
-        val escaped = when (char) {
+        when (it) {
-            '\n' -> "\\n"
+            '\n' -> append("\\n")
-            '\r' -> "\\r"
+            '\r' -> append("\\r")
-            '\t' -> "\\t"
+            '\t' -> append("\\t")
-            '\"' -> "\\\""
+            '"' -> append("\\\"")
-            '\\' -> "\\\\"
+            '\\' -> append("\\\\")
-            else -> "$char"
+            else -> if (it.code in 32..128) {
+                append(it)
+            } else {
+                append("\\u%04X".format(it.code))
+            }
         }
-        append(escaped)
     }
 }
 
@@ -180,11 +183,11 @@ internal fun KtAnnotationValue.toAnnotationMemberValue(parent: PsiElement): PsiA
         )
 
     is KtConstantAnnotationValue -> {
-        this.constantValue.createPsiExpression(parent)?.let {
+        constantValue.createPsiExpression(parent)?.let {
-            if (it is PsiLiteral)
+            when (it) {
-                SymbolPsiLiteral(sourcePsi, parent, it)
+                is PsiLiteral -> SymbolPsiLiteral(sourcePsi, parent, it)
-            else
+                else -> SymbolPsiExpression(sourcePsi, parent, it)
-                SymbolPsiExpression(sourcePsi, parent, it)
+            }
         }
     }
 
@@ -220,23 +223,30 @@ private fun KtKClassAnnotationValue.toAnnotationMemberValue(parent: PsiElement):
     }
 }
 
-private fun KtConstantValue.asStringForPsiLiteral(): String = when (val value = value) {
+private fun KtConstantValue.asStringForPsiExpression(): String =
-    is Char -> "'$value'"
+    when (val value = value) {
-    is String -> "\"${escapeString(value)}\""
+        Double.NEGATIVE_INFINITY -> "-1.0 / 0.0"
-    is Long -> "${value}L"
+        Double.NaN -> "0.0 / 0.0"
-    is Float -> "${value}f"
+        Double.POSITIVE_INFINITY -> "1.0 / 0.0"
-    null -> "null"
+        Float.NEGATIVE_INFINITY -> "-1.0F / 0.0F"
-    else -> value.toString()
+        Float.NaN -> "0.0F / 0.0F"
-}
+        Float.POSITIVE_INFINITY -> "1.0F / 0.0F"
+        '\'' -> "'\\''"
+        is Char -> "'${escapeString(value.toString())}'"
+        is String -> "\"${escapeString(value)}\""
+        is Long -> "${value}L"
+        is Float -> "${value}f"
+        else -> value.toString()
+    }
 
 internal fun KtConstantValue.createPsiExpression(parent: PsiElement): PsiExpression? {
-    val asString = asStringForPsiLiteral()
+    val asString = asStringForPsiExpression()
     return parent.project.withElementFactorySafe {
         createExpressionFromText(asString, parent)
     }
 }
 
-private inline fun <T> Project.withElementFactorySafe(crossinline action: PsiElementFactory.() -> T): T? {
+internal inline fun <T> Project.withElementFactorySafe(crossinline action: PsiElementFactory.() -> T): T? {
     val instance = PsiElementFactory.getInstance(this)
     return try {
         instance.action()

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByFqNameForLibraryTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesByFqNameForLibraryTestGenerated extends AbstractS
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByPsiForLibraryTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesByPsiForLibraryTestGenerated extends AbstractSymb
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesEqualityByFqNameForLibraryTestGenerated extends A
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesEqualityByPsiForLibraryTestGenerated extends Abst
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByFqNameForLibraryTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesParentingByFqNameForLibraryTestGenerated extends
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesParentingByPsiForLibraryTestGenerated extends Abs
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByFqNameForSourceTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesByFqNameForSourceTestGenerated extends AbstractSy
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByPsiForSourceTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesByPsiForSourceTestGenerated extends AbstractSymbo
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesEqualityByFqNameForSourceTestGenerated extends Ab
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesEqualityByPsiForSourceTestGenerated extends Abstr
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByFqNameForSourceTestGenerated.java

@@ -192,6 +192,12 @@ public class SymbolLightClassesParentingByFqNameForSourceTestGenerated extends A
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @Test
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @Test
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {

analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java

@@ -318,6 +318,12 @@ public class SymbolLightClassesParentingByPsiForSourceTestGenerated extends Abst
         runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unresolvedWithAliasedImport.kt");
     }
 
+    @Test
+    @TestMetadata("unsafePropertyInitializers.kt")
+    public void testUnsafePropertyInitializers() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt");
+    }
+
     @Test
     @TestMetadata("valueClassInSignature.kt")
     public void testValueClassInSignature() throws Exception {

compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.java

@@ -0,0 +1,15 @@
+public final class Big /* Big*/ {
+  @org.jetbrains.annotations.NotNull()
+  private final Size size;
+
+  @org.jetbrains.annotations.NotNull()
+  private final Size[] sizes;
+
+  @org.jetbrains.annotations.NotNull()
+  public final Size getSize();//  getSize()
+
+  @org.jetbrains.annotations.NotNull()
+  public final Size[] getSizes();//  getSizes()
+
+  public  Big();//  .ctor()
+}

compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt

@@ -0,0 +1,7 @@
+// Big
+enum class Size { `2x2`, `3x3` }
+
+class Big {
+    val size = Size.`3x3`
+    val sizes = arrayOf(Size.`3x3`)
+}

compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.fir.java

@@ -6,7 +6,7 @@ public final class PropertiesKt /* PropertiesKt*/ {
   private static final error.NonExistentClass delegatedProp2$delegate;
 
   @org.jetbrains.annotations.NotNull()
-  private static final java.lang.Object arrayConst;
+  private static final java.lang.Object arrayConst = {1, 2} /* initializer type: null */;
 
   @org.jetbrains.annotations.NotNull()
   private static final java.lang.String x = "" /* initializer type: java.lang.String */;

compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.descriptors.java

@@ -0,0 +1,91 @@
+public final class UnsafePropertyInitializersKt /* UnsafePropertyInitializersKt*/ {
+  @org.jetbrains.annotations.NotNull()
+  private static final char[] arrayOfCharPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final double[] arrayOfDoublePrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final float[] arrayOfFloatPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final int[] arrayOfIntPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Character[] arrayOfCharObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Double[] arrayOfDoubleObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Float[] arrayOfFloatObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Integer[] arrayOfIntObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Long[] arrayOfLongObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Object[] arrayOfNAny;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.String[] arrayOfStrings;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.util.List<java.lang.String> listOfStrings;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final kotlin.annotation.AnnotationTarget[] arrayOfEnums;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final long[] arrayOfLongPrimitives;
+
+  @org.jetbrains.annotations.Nullable()
+  private static final java.lang.String nullable;
+
+  @org.jetbrains.annotations.NotNull()
+  public static final char[] getArrayOfCharPrimitives();//  getArrayOfCharPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final double[] getArrayOfDoublePrimitives();//  getArrayOfDoublePrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final float[] getArrayOfFloatPrimitives();//  getArrayOfFloatPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final int[] getArrayOfIntPrimitives();//  getArrayOfIntPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Character[] getArrayOfCharObjects();//  getArrayOfCharObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Double[] getArrayOfDoubleObjects();//  getArrayOfDoubleObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Float[] getArrayOfFloatObjects();//  getArrayOfFloatObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Integer[] getArrayOfIntObjects();//  getArrayOfIntObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Long[] getArrayOfLongObjects();//  getArrayOfLongObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Object[] getArrayOfNAny();//  getArrayOfNAny()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.String[] getArrayOfStrings();//  getArrayOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.util.List<java.lang.String> getListOfStrings();//  getListOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final kotlin.annotation.AnnotationTarget[] getArrayOfEnums();//  getArrayOfEnums()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final long[] getArrayOfLongPrimitives();//  getArrayOfLongPrimitives()
+
+  @org.jetbrains.annotations.Nullable()
+  public static final java.lang.String getNullable();//  getNullable()
+}

compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.java

@@ -0,0 +1,91 @@
+public final class UnsafePropertyInitializersKt /* UnsafePropertyInitializersKt*/ {
+  @org.jetbrains.annotations.NotNull()
+  private static final char[] arrayOfCharPrimitives = {'C', '\u0000', '\n', '\r', '\'', '\u00FF'} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final double[] arrayOfDoublePrimitives = {5.0, -1.23E-7, 4.9E-324, 1.7976931348623157E308, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final float[] arrayOfFloatPrimitives = {5.0f, -1.23E-7f, 1.4E-45f, 3.4028235E38f, 0.0F / 0.0F, 1.0F / 0.0F, -1.0F / 0.0F, 0.0F / 0.0F, 1.0F / 0.0F, -1.0F / 0.0F} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final int[] arrayOfIntPrimitives = {5, -1, 2147483647, -2147483648} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Character[] arrayOfCharObjects = {'C', '\u0000', '\n', '\r', '\'', '\u00FF'} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Double[] arrayOfDoubleObjects = {5.0, -1.23E-7, 4.9E-324, 1.7976931348623157E308, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Float[] arrayOfFloatObjects = {5.0f, -1.23E-7f, 1.4E-45f, 3.4028235E38f, 0.0F / 0.0F, 1.0F / 0.0F, -1.0F / 0.0F, 0.0F / 0.0F, 1.0F / 0.0F, -1.0F / 0.0F} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Integer[] arrayOfIntObjects = {5, -1, 2147483647, -2147483648} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Long[] arrayOfLongObjects = {5L, -1L, 9223372036854775807L, -9223372036854775808L} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Object[] arrayOfNAny = {1, 2L, "abc", kotlin.annotation.AnnotationTarget.CLASS, null} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.String[] arrayOfStrings = {"", "quotes \" ''quotes", "\r\n", "\u4F60\u597D\u4E16\u754C"} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.util.List<java.lang.String> listOfStrings;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final kotlin.annotation.AnnotationTarget[] arrayOfEnums = {kotlin.annotation.AnnotationTarget.CLASS, kotlin.annotation.AnnotationTarget.PROPERTY} /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final long[] arrayOfLongPrimitives = {5L, -1L, 9223372036854775807L, -9223372036854775808L} /* initializer type: null */;
+
+  @org.jetbrains.annotations.Nullable()
+  private static final java.lang.String nullable = null /* initializer type: null */;
+
+  @org.jetbrains.annotations.NotNull()
+  public static final char[] getArrayOfCharPrimitives();//  getArrayOfCharPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final double[] getArrayOfDoublePrimitives();//  getArrayOfDoublePrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final float[] getArrayOfFloatPrimitives();//  getArrayOfFloatPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final int[] getArrayOfIntPrimitives();//  getArrayOfIntPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Character[] getArrayOfCharObjects();//  getArrayOfCharObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Double[] getArrayOfDoubleObjects();//  getArrayOfDoubleObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Float[] getArrayOfFloatObjects();//  getArrayOfFloatObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Integer[] getArrayOfIntObjects();//  getArrayOfIntObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Long[] getArrayOfLongObjects();//  getArrayOfLongObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Object[] getArrayOfNAny();//  getArrayOfNAny()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.String[] getArrayOfStrings();//  getArrayOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.util.List<java.lang.String> getListOfStrings();//  getListOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final kotlin.annotation.AnnotationTarget[] getArrayOfEnums();//  getArrayOfEnums()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final long[] getArrayOfLongPrimitives();//  getArrayOfLongPrimitives()
+
+  @org.jetbrains.annotations.Nullable()
+  public static final java.lang.String getNullable();//  getNullable()
+}

compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt

@@ -0,0 +1,15 @@
+val nullable: String? = null
+val listOfStrings = listOf("no lists, sorry")
+val arrayOfIntObjects = arrayOf(2 + 3, -1, Int.MAX_VALUE, Int.MIN_VALUE)
+val arrayOfIntPrimitives = intArrayOf(2 + 3, -1, Int.MAX_VALUE, Int.MIN_VALUE)
+val arrayOfLongObjects = arrayOf(2L + 3L, -1L, Long.MAX_VALUE, Long.MIN_VALUE)
+val arrayOfLongPrimitives = longArrayOf(2L + 3L, -1L, Long.MAX_VALUE, Long.MIN_VALUE)
+val arrayOfCharObjects = arrayOf('C', 0.toChar(), '\n', '\r', '\'', 0xff.toChar())
+val arrayOfCharPrimitives = charArrayOf('C', 0.toChar(), '\n', '\r', '\'', 0xff.toChar())
+val arrayOfDoubleObjects = arrayOf(2.0 + 3.0, -1.23E-7, Double.MIN_VALUE, Double.MAX_VALUE, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0)
+val arrayOfDoublePrimitives = doubleArrayOf(2.0 + 3.0, -1.23E-7, Double.MIN_VALUE, Double.MAX_VALUE, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY, 0.0 / 0.0, 1.0 / 0.0, -1.0 / 0.0)
+val arrayOfFloatObjects = arrayOf(2f + 3f, -1.23E-7f, Float.MIN_VALUE, Float.MAX_VALUE, Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, 0.0f / 0.0f, 1.0f / 0.0f, -1.0f / 0.0f)
+val arrayOfFloatPrimitives = floatArrayOf(2f + 3f, -1.23E-7f, Float.MIN_VALUE, Float.MAX_VALUE, Float.NaN, Float.POSITIVE_INFINITY, Float.NEGATIVE_INFINITY, 0.0f / 0.0f, 1.0f / 0.0f, -1.0f / 0.0f)
+val arrayOfStrings = arrayOf("", "quotes \" ''quotes", "\r\n", "你好世界")
+val arrayOfEnums = arrayOf(AnnotationTarget.CLASS, AnnotationTarget.PROPERTY)
+val arrayOfNAny = arrayOf(1, 2L, "abc", AnnotationTarget.CLASS, null)

compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.lib.java

@@ -0,0 +1,91 @@
+public final class UnsafePropertyInitializersKt /* UnsafePropertyInitializersKt*/ {
+  @org.jetbrains.annotations.NotNull()
+  private static final char[] arrayOfCharPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final double[] arrayOfDoublePrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final float[] arrayOfFloatPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final int[] arrayOfIntPrimitives;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Character[] arrayOfCharObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Double[] arrayOfDoubleObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Float[] arrayOfFloatObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Integer[] arrayOfIntObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Long[] arrayOfLongObjects;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.Object[] arrayOfNAny;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.lang.String[] arrayOfStrings;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final java.util.List<java.lang.String> listOfStrings;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final kotlin.annotation.AnnotationTarget[] arrayOfEnums;
+
+  @org.jetbrains.annotations.NotNull()
+  private static final long[] arrayOfLongPrimitives;
+
+  @org.jetbrains.annotations.Nullable()
+  private static final java.lang.String nullable;
+
+  @org.jetbrains.annotations.NotNull()
+  public static final char[] getArrayOfCharPrimitives();//  getArrayOfCharPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final double[] getArrayOfDoublePrimitives();//  getArrayOfDoublePrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final float[] getArrayOfFloatPrimitives();//  getArrayOfFloatPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final int[] getArrayOfIntPrimitives();//  getArrayOfIntPrimitives()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Character[] getArrayOfCharObjects();//  getArrayOfCharObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Double[] getArrayOfDoubleObjects();//  getArrayOfDoubleObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Float[] getArrayOfFloatObjects();//  getArrayOfFloatObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Integer[] getArrayOfIntObjects();//  getArrayOfIntObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Long[] getArrayOfLongObjects();//  getArrayOfLongObjects()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.Object[] getArrayOfNAny();//  getArrayOfNAny()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.lang.String[] getArrayOfStrings();//  getArrayOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final java.util.List<java.lang.String> getListOfStrings();//  getListOfStrings()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final kotlin.annotation.AnnotationTarget[] getArrayOfEnums();//  getArrayOfEnums()
+
+  @org.jetbrains.annotations.NotNull()
+  public static final long[] getArrayOfLongPrimitives();//  getArrayOfLongPrimitives()
+
+  @org.jetbrains.annotations.Nullable()
+  public static final java.lang.String getNullable();//  getNullable()
+}

compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java

@@ -169,6 +169,11 @@ public class CompilerLightClassTestGenerated extends AbstractCompilerLightClassT
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsAnnotationArgument.kt");
     }
 
+    @TestMetadata("InvalidJavaIdentifierAsPropertyInitializer.kt")
+    public void testInvalidJavaIdentifierAsPropertyInitializer() throws Exception {
+        runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt");
+    }
+
     @TestMetadata("JavaBetween.kt")
     public void testJavaBetween() throws Exception {
         runTest("compiler/testData/asJava/lightClasses/lightClassByFqName/JavaBetween.kt");

plugins/kapt3/kapt3-compiler/testData/converter/implicitReturnTypes.fir.txt

@@ -0,0 +1,73 @@
+package lib;
+
+public abstract class Prop<T> {
+
+    public Prop() {
+        super();
+    }
+
+    public abstract int get(T key);
+
+    public abstract void set(T key, int value);
+}
+
+////////////////////
+
+package test;
+
+import java.lang.System;
+
+@kotlin.Metadata()
+public final class Cl {
+    @org.jetbrains.annotations.NotNull()
+    private java.lang.String name;
+
+    public Cl(@org.jetbrains.annotations.NotNull()
+    java.lang.String name) {
+        super();
+    }
+
+    @org.jetbrains.annotations.NotNull()
+    public final java.lang.String getName() {
+        return null;
+    }
+
+    public final void setName(@org.jetbrains.annotations.NotNull()
+    java.lang.String p0) {
+    }
+}
+
+////////////////////
+
+package test;
+
+import java.lang.System;
+
+@kotlin.Metadata()
+public final class TestKt {
+
+    public TestKt() {
+        super();
+    }
+    @org.jetbrains.annotations.NotNull()
+    private static final lib.Prop<test.Cl> TEST = null;
+    @org.jetbrains.annotations.NotNull()
+    private static final lib.Prop<test.Cl>[] TESTS_ARRAY = {};
+    @org.jetbrains.annotations.NotNull()
+    private static final java.util.List<lib.Prop<test.Cl>> TESTS_LIST = null;
+
+    @org.jetbrains.annotations.NotNull()
+    public static final lib.Prop<test.Cl> getTEST() {
+        return null;
+    }
+
+    @org.jetbrains.annotations.NotNull()
+    public static final lib.Prop<test.Cl>[] getTESTS_ARRAY() {
+        return null;
+    }
+
+    @org.jetbrains.annotations.NotNull()
+    public static final java.util.List<lib.Prop<test.Cl>> getTESTS_LIST() {
+        return null;
+    }
+}