From 85b5a4521e0a06e876441c3d37d10288c387144f Mon Sep 17 00:00:00 2001 From: Pavel Mikhailovskii Date: Tue, 28 Mar 2023 08:17:37 +0000 Subject: [PATCH] KT-56843 [SLC] Support unsafe property initializers --- .../KtFe10CompileTimeConstantProvider.kt | 9 ++ .../KtFirCompileTimeConstantProvider.kt | 8 ++ .../evaluate/FirAnnotationValueConverter.kt | 7 +- .../kotlin/analysis/api/KtInitializerValue.kt | 2 +- .../KtCompileTimeConstantProvider.kt | 14 +++ .../fields/SymbolLightFieldForProperty.kt | 26 +++++- .../light/classes/symbol/symbolLightUtils.kt | 60 +++++++----- ...lassesByFqNameForLibraryTestGenerated.java | 6 ++ ...htClassesByPsiForLibraryTestGenerated.java | 6 ++ ...ualityByFqNameForLibraryTestGenerated.java | 6 ++ ...sEqualityByPsiForLibraryTestGenerated.java | 6 ++ ...entingByFqNameForLibraryTestGenerated.java | 6 ++ ...ParentingByPsiForLibraryTestGenerated.java | 6 ++ ...ClassesByFqNameForSourceTestGenerated.java | 6 ++ ...ghtClassesByPsiForSourceTestGenerated.java | 6 ++ ...qualityByFqNameForSourceTestGenerated.java | 6 ++ ...esEqualityByPsiForSourceTestGenerated.java | 6 ++ ...rentingByFqNameForSourceTestGenerated.java | 6 ++ ...sParentingByPsiForSourceTestGenerated.java | 6 ++ ...idJavaIdentifierAsPropertyInitializer.java | 15 +++ ...alidJavaIdentifierAsPropertyInitializer.kt | 7 ++ .../facades/properties.fir.java | 2 +- ...nsafePropertyInitializers.descriptors.java | 91 +++++++++++++++++++ .../unsafePropertyInitializers.java | 91 +++++++++++++++++++ .../unsafePropertyInitializers.kt | 15 +++ .../unsafePropertyInitializers.lib.java | 91 +++++++++++++++++++ .../CompilerLightClassTestGenerated.java | 5 + .../converter/implicitReturnTypes.fir.txt | 73 +++++++++++++++ 28 files changed, 556 insertions(+), 32 deletions(-) create mode 100644 compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.java create mode 100644 compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt create mode 100644 compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.descriptors.java create mode 100644 compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.java create mode 100644 compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt create mode 100644 compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.lib.java create mode 100644 plugins/kapt3/kapt3-compiler/testData/converter/implicitReturnTypes.fir.txt diff --git a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt b/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt index c58e4ad90af..1dd7aa2732c 100644 --- a/analysis/analysis-api-fe10/src/org/jetbrains/kotlin/analysis/api/descriptors/components/KtFe10CompileTimeConstantProvider.kt +++ b/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) + } } diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt index a45e7972830..9579734f6a4 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/components/KtFirCompileTimeConstantProvider.kt +++ b/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, diff --git a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt b/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt index d82745e5627..3a2d9126112 100644 --- a/analysis/analysis-api-fir/src/org/jetbrains/kotlin/analysis/api/fir/evaluate/FirAnnotationValueConverter.kt +++ b/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.convertVarargsExpression( diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtInitializerValue.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtInitializerValue.kt index 8f2119dcea2..cb89cf03040 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/KtInitializerValue.kt +++ b/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() /** diff --git a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtCompileTimeConstantProvider.kt b/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtCompileTimeConstantProvider.kt index ae9d779e306..08137555e1c 100644 --- a/analysis/analysis-api/src/org/jetbrains/kotlin/analysis/api/components/KtCompileTimeConstantProvider.kt +++ b/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) } } diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForProperty.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForProperty.kt index ad99aef226e..aade643d491 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/fields/SymbolLightFieldForProperty.kt +++ b/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 { diff --git a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt b/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt index 26c66066d63..7a38c59ca84 100644 --- a/analysis/symbol-light-classes/src/org/jetbrains/kotlin/light/classes/symbol/symbolLightUtils.kt +++ b/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 { - str.forEach { char -> - val escaped = when (char) { - '\n' -> "\\n" - '\r' -> "\\r" - '\t' -> "\\t" - '\"' -> "\\\"" - '\\' -> "\\\\" - else -> "$char" +private fun escapeString(s: String): String = buildString { + s.forEach { + when (it) { + '\n' -> append("\\n") + '\r' -> append("\\r") + '\t' -> append("\\t") + '"' -> append("\\\"") + '\\' -> append("\\\\") + 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 { - if (it is PsiLiteral) - SymbolPsiLiteral(sourcePsi, parent, it) - else - SymbolPsiExpression(sourcePsi, parent, it) + constantValue.createPsiExpression(parent)?.let { + when (it) { + is PsiLiteral -> SymbolPsiLiteral(sourcePsi, parent, it) + else -> SymbolPsiExpression(sourcePsi, parent, it) + } } } @@ -220,23 +223,30 @@ private fun KtKClassAnnotationValue.toAnnotationMemberValue(parent: PsiElement): } } -private fun KtConstantValue.asStringForPsiLiteral(): String = when (val value = value) { - is Char -> "'$value'" - is String -> "\"${escapeString(value)}\"" - is Long -> "${value}L" - is Float -> "${value}f" - null -> "null" - else -> value.toString() -} +private fun KtConstantValue.asStringForPsiExpression(): String = + when (val value = value) { + Double.NEGATIVE_INFINITY -> "-1.0 / 0.0" + Double.NaN -> "0.0 / 0.0" + Double.POSITIVE_INFINITY -> "1.0 / 0.0" + Float.NEGATIVE_INFINITY -> "-1.0F / 0.0F" + 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 Project.withElementFactorySafe(crossinline action: PsiElementFactory.() -> T): T? { +internal inline fun Project.withElementFactorySafe(crossinline action: PsiElementFactory.() -> T): T? { val instance = PsiElementFactory.getInstance(this) return try { instance.action() diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByFqNameForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByFqNameForLibraryTestGenerated.java index 1c79ca6620d..b89ba502df9 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByFqNameForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByPsiForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByPsiForLibraryTestGenerated.java index 7faf340a22c..f1d72aea3d8 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesByPsiForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java index c527db84f72..a1a24c661b5 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByFqNameForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java index 782d0ae5730..089fe06f716 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesEqualityByPsiForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByFqNameForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByFqNameForLibraryTestGenerated.java index 685834d5a7b..ac0452a4348 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByFqNameForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java index 2c9d62ab6a2..e24e92076f8 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/decompiled/SymbolLightClassesParentingByPsiForLibraryTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByFqNameForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByFqNameForSourceTestGenerated.java index 91d9fb31ce3..94fa43505c7 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByFqNameForSourceTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByPsiForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByPsiForSourceTestGenerated.java index b44d1825fc1..d005e7a2f0b 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesByPsiForSourceTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java index fd7f22d86b5..ef21c6c1f5e 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByFqNameForSourceTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java index 92678663ef8..625e542f0aa 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesEqualityByPsiForSourceTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByFqNameForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByFqNameForSourceTestGenerated.java index 4598affd7bf..588f803f9ce 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByFqNameForSourceTestGenerated.java +++ b/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 { diff --git a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java b/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java index f2eaa6672aa..b3a4d4ef023 100644 --- a/analysis/symbol-light-classes/tests/org/jetbrains/kotlin/light/classes/symbol/source/SymbolLightClassesParentingByPsiForSourceTestGenerated.java +++ b/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 { diff --git a/compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.java b/compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.java new file mode 100644 index 00000000000..6bf09dad6e9 --- /dev/null +++ b/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() +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt b/compiler/testData/asJava/lightClasses/lightClassByFqName/InvalidJavaIdentifierAsPropertyInitializer.kt new file mode 100644 index 00000000000..f381409372c --- /dev/null +++ b/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`) +} \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.fir.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.fir.java index 881d74b5c9b..5309b49a0ea 100644 --- a/compiler/testData/asJava/lightClasses/lightClassByPsi/facades/properties.fir.java +++ b/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 */; diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.descriptors.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.descriptors.java new file mode 100644 index 00000000000..c52f005546e --- /dev/null +++ b/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 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 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() +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.java new file mode 100644 index 00000000000..b0bb2178650 --- /dev/null +++ b/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 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 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() +} diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt b/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.kt new file mode 100644 index 00000000000..3e1568e87c4 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.lib.java b/compiler/testData/asJava/lightClasses/lightClassByPsi/unsafePropertyInitializers.lib.java new file mode 100644 index 00000000000..c52f005546e --- /dev/null +++ b/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 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 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() +} diff --git a/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java b/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java index 447898000a6..6a73e7a3d26 100644 --- a/compiler/tests-gen/org/jetbrains/kotlin/asJava/CompilerLightClassTestGenerated.java +++ b/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"); diff --git a/plugins/kapt3/kapt3-compiler/testData/converter/implicitReturnTypes.fir.txt b/plugins/kapt3/kapt3-compiler/testData/converter/implicitReturnTypes.fir.txt new file mode 100644 index 00000000000..a1f712838ea --- /dev/null +++ b/plugins/kapt3/kapt3-compiler/testData/converter/implicitReturnTypes.fir.txt @@ -0,0 +1,73 @@ +package lib; + +public abstract class Prop { + + 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 = null; + @org.jetbrains.annotations.NotNull() + private static final lib.Prop[] TESTS_ARRAY = {}; + @org.jetbrains.annotations.NotNull() + private static final java.util.List> TESTS_LIST = null; + + @org.jetbrains.annotations.NotNull() + public static final lib.Prop getTEST() { + return null; + } + + @org.jetbrains.annotations.NotNull() + public static final lib.Prop[] getTESTS_ARRAY() { + return null; + } + + @org.jetbrains.annotations.NotNull() + public static final java.util.List> getTESTS_LIST() { + return null; + } +}