diff --git a/compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations/DefaultEnum.fir.txt b/compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations/DefaultEnum.fir.txt index 0a4deeaf888..4aa3a27d177 100644 --- a/compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations/DefaultEnum.fir.txt +++ b/compiler/fir/analysis-tests/testData/enhancement/signatureAnnotations/DefaultEnum.fir.txt @@ -11,8 +11,7 @@ public/*package*/ open class A : R|kotlin/Any| { } public final enum class Mixed : R|kotlin/Enum!>| { - public final static field NOT_ENTRY_EITHER: R|Mixed| - + public final static enum entry NOT_ENTRY_EITHER: R|Mixed| public final static fun values(): R|kotlin/Array| { } @@ -21,10 +20,8 @@ public final enum class Mixed : R|kotlin/Enum!>| { } public final enum class Signs : R|kotlin/Enum!>| { - public final static field HELLO: R|Signs| - - public final static field WORLD: R|Signs| - + public final static enum entry HELLO: R|Signs| + public final static enum entry WORLD: R|Signs| public final static field X: R|ft!| public final static fun values(): R|kotlin/Array| { diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt new file mode 100644 index 00000000000..7e428a3fb2e --- /dev/null +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt @@ -0,0 +1,60 @@ +// FILE: JavaEnum.java +public enum JavaEnum { + A, B, C; + + public int i = 0; +} + +// FILE: main.kt +fun test_1(e: JavaEnum) { + val a = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + }.plus(0) + + val b = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + is String -> 3 + }.plus(0) + + val c = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + JavaEnum.C -> 3 + }.plus(0) + + val d = when (e) { + JavaEnum.A -> 1 + else -> 2 + }.plus(0) +} + +fun test_2(e: JavaEnum?) { + val a = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + JavaEnum.C -> 3 + }.plus(0) + + val a = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + JavaEnum.C -> 3 + null -> 4 + }.plus(0) + + val a = when (e) { + JavaEnum.A -> 1 + JavaEnum.B -> 2 + JavaEnum.C -> 3 + else -> 4 + }.plus(0) +} + +fun test_3(e: JavaEnum) { + val a = when (e) { + JavaEnum.A, JavaEnum.B -> 1 + JavaEnum.C -> 2 + }.plus(0) +} \ No newline at end of file diff --git a/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.txt b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.txt new file mode 100644 index 00000000000..f3b8d19e300 --- /dev/null +++ b/compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.txt @@ -0,0 +1,100 @@ +FILE: main.kt + public final fun test_1(e: R|JavaEnum|): R|kotlin/Unit| { + lval a: = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + } + .#(Int(0)) + lval b: = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + ($subj$ is R|kotlin/String|) -> { + Int(3) + } + } + .#(Int(0)) + lval c: R|kotlin/Int| = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.C|) -> { + Int(3) + } + } + .R|kotlin/Int.plus|(Int(0)) + lval d: R|kotlin/Int| = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + else -> { + Int(2) + } + } + .R|kotlin/Int.plus|(Int(0)) + } + public final fun test_2(e: R|JavaEnum?|): R|kotlin/Unit| { + lval a: = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.C|) -> { + Int(3) + } + } + .#(Int(0)) + lval a: R|kotlin/Int| = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.C|) -> { + Int(3) + } + ==($subj$, Null(null)) -> { + Int(4) + } + } + .R|kotlin/Int.plus|(Int(0)) + lval a: R|kotlin/Int| = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(2) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.C|) -> { + Int(3) + } + else -> { + Int(4) + } + } + .R|kotlin/Int.plus|(Int(0)) + } + public final fun test_3(e: R|JavaEnum|): R|kotlin/Unit| { + lval a: R|kotlin/Int| = when (R|/e|) { + ==($subj$, Q|JavaEnum|.R|/JavaEnum.A|) || ==($subj$, Q|JavaEnum|.R|/JavaEnum.B|) -> { + Int(1) + } + ==($subj$, Q|JavaEnum|.R|/JavaEnum.C|) -> { + Int(2) + } + } + .R|kotlin/Int.plus|(Int(0)) + } diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java index c36753d477f..d0e0dedef1a 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java +++ b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsTestGenerated.java @@ -133,6 +133,11 @@ public class FirDiagnosticsTestGenerated extends AbstractFirDiagnosticsTest { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt"); } + @TestMetadata("exhaustiveness_enumJava.kt") + public void testExhaustiveness_enumJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt"); + } + @TestMetadata("exhaustiveness_sealedClass.kt") public void testExhaustiveness_sealedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt"); diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java index 65d8304c462..29228cbf02c 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java +++ b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/FirDiagnosticsWithLightTreeTestGenerated.java @@ -133,6 +133,11 @@ public class FirDiagnosticsWithLightTreeTestGenerated extends AbstractFirDiagnos runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enum.kt"); } + @TestMetadata("exhaustiveness_enumJava.kt") + public void testExhaustiveness_enumJava() throws Exception { + runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_enumJava.kt"); + } + @TestMetadata("exhaustiveness_sealedClass.kt") public void testExhaustiveness_sealedClass() throws Exception { runTest("compiler/fir/analysis-tests/testData/resolve/exhaustiveness_sealedClass.kt"); diff --git a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt index be017d9a138..4317f66982a 100644 --- a/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt +++ b/compiler/fir/analysis-tests/tests/org/jetbrains/kotlin/fir/java/JavaClassRendering.kt @@ -9,12 +9,14 @@ import org.jetbrains.kotlin.fir.FirRenderer import org.jetbrains.kotlin.fir.FirSession import org.jetbrains.kotlin.fir.declarations.FirCallableMemberDeclaration import org.jetbrains.kotlin.fir.declarations.FirDeclaration +import org.jetbrains.kotlin.fir.declarations.FirEnumEntry import org.jetbrains.kotlin.fir.java.declarations.FirJavaClass import org.jetbrains.kotlin.fir.java.declarations.FirJavaConstructor import org.jetbrains.kotlin.fir.java.declarations.FirJavaField import org.jetbrains.kotlin.fir.java.declarations.FirJavaMethod import org.jetbrains.kotlin.fir.resolve.ScopeSession import org.jetbrains.kotlin.fir.resolve.buildUseSiteMemberScope +import org.jetbrains.kotlin.fir.symbols.impl.FirCallableSymbol fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: FirSession) { val memberScope = javaClass.buildUseSiteMemberScope(session, ScopeSession()) @@ -28,6 +30,16 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir renderer.renderSupertypes(javaClass) renderer.renderInBraces { val renderedDeclarations = mutableListOf() + + fun renderAndCache(symbol: FirCallableSymbol<*>) { + val enhanced = symbol.fir + if (enhanced !in renderedDeclarations) { + enhanced.accept(renderer, null) + renderer.newLine() + renderedDeclarations += enhanced + } + } + for (declaration in javaClass.declarations) { if (declaration in renderedDeclarations) continue @@ -38,30 +50,10 @@ fun renderJavaClass(renderer: FirRenderer, javaClass: FirJavaClass, session: Fir memberScope when (declaration) { - is FirJavaConstructor -> scopeToUse!!.processDeclaredConstructors { symbol -> - val enhanced = symbol.fir - if (enhanced !in renderedDeclarations) { - enhanced.accept(renderer, null) - renderer.newLine() - renderedDeclarations += enhanced - } - } - is FirJavaMethod -> scopeToUse!!.processFunctionsByName(declaration.name) { symbol -> - val enhanced = symbol.fir - if (enhanced !in renderedDeclarations) { - enhanced.accept(renderer, null) - renderer.newLine() - renderedDeclarations += enhanced - } - } - is FirJavaField -> scopeToUse!!.processPropertiesByName(declaration.name) { symbol -> - val enhanced = symbol.fir - if (enhanced !in renderedDeclarations) { - enhanced.accept(renderer, null) - renderer.newLine() - renderedDeclarations += enhanced - } - } + is FirJavaConstructor -> scopeToUse!!.processDeclaredConstructors(::renderAndCache) + is FirJavaMethod -> scopeToUse!!.processFunctionsByName(declaration.name, ::renderAndCache) + is FirJavaField -> scopeToUse!!.processPropertiesByName(declaration.name, ::renderAndCache) + is FirEnumEntry -> scopeToUse!!.processPropertiesByName(declaration.name, ::renderAndCache) else -> { declaration.accept(renderer, null) renderer.newLine() diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt index 7176033f05a..a9e9d7b7e7e 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/JavaSymbolProvider.kt @@ -11,16 +11,10 @@ import com.intellij.psi.PsiElement import com.intellij.psi.search.GlobalSearchScope import org.jetbrains.kotlin.descriptors.ClassKind import org.jetbrains.kotlin.descriptors.Visibility -import org.jetbrains.kotlin.fir.FirSession -import org.jetbrains.kotlin.fir.declarations.FirDeclarationOrigin -import org.jetbrains.kotlin.fir.declarations.FirRegularClass -import org.jetbrains.kotlin.fir.declarations.FirTypeParameter -import org.jetbrains.kotlin.fir.declarations.addDefaultBoundIfNecessary -import org.jetbrains.kotlin.fir.declarations.builder.FirTypeParameterBuilder -import org.jetbrains.kotlin.fir.declarations.builder.buildConstructedClassTypeParameterRef -import org.jetbrains.kotlin.fir.declarations.builder.buildOuterClassTypeParameterRef -import org.jetbrains.kotlin.fir.generateValueOfFunction -import org.jetbrains.kotlin.fir.generateValuesFunction +import org.jetbrains.kotlin.fir.* +import org.jetbrains.kotlin.fir.declarations.* +import org.jetbrains.kotlin.fir.declarations.builder.* +import org.jetbrains.kotlin.fir.declarations.impl.FirDeclarationStatusImpl import org.jetbrains.kotlin.fir.java.declarations.* import org.jetbrains.kotlin.fir.resolve.constructType import org.jetbrains.kotlin.fir.resolve.providers.AbstractFirSymbolProvider @@ -30,7 +24,6 @@ import org.jetbrains.kotlin.fir.scopes.impl.lazyNestedClassifierScope import org.jetbrains.kotlin.fir.scopes.impl.nestedClassifierScope import org.jetbrains.kotlin.fir.symbols.CallableId import org.jetbrains.kotlin.fir.symbols.impl.* -import org.jetbrains.kotlin.fir.toFirPsiSourceElement import org.jetbrains.kotlin.fir.types.builder.buildResolvedTypeRef import org.jetbrains.kotlin.fir.types.impl.ConeTypeParameterTypeImpl import org.jetbrains.kotlin.load.java.JavaClassFinder @@ -191,22 +184,39 @@ class JavaSymbolProvider( for (javaField in javaClass.fields) { val fieldName = javaField.name val fieldId = CallableId(classId.packageFqName, classId.relativeClassName, fieldName) - val fieldSymbol = FirFieldSymbol(fieldId) val returnType = javaField.type - val firJavaField = buildJavaField { - source = (javaField as? JavaElementImpl<*>)?.psi?.toFirPsiSourceElement() - session = this@JavaSymbolProvider.session - symbol = fieldSymbol - name = fieldName - visibility = javaField.visibility - modality = javaField.modality - returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack) - isVar = !javaField.isFinal - isStatic = javaField.isStatic - isEnumEntry = javaField.isEnumEntry - addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) + val firJavaDeclaration = when { + javaField.isEnumEntry -> buildEnumEntry { + source = (javaField as? JavaElementImpl<*>)?.psi?.toFirPsiSourceElement() + session = this@JavaSymbolProvider.session + symbol = FirVariableSymbol(fieldId) + name = fieldName + status = FirDeclarationStatusImpl(javaField.visibility, javaField.modality).apply { + isStatic = javaField.isStatic + isExpect = false + isActual = false + isOverride = false + } + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack) + resolvePhase = FirResolvePhase.ANALYZED_DEPENDENCIES + origin = FirDeclarationOrigin.Java + addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) + } + else -> buildJavaField { + source = (javaField as? JavaElementImpl<*>)?.psi?.toFirPsiSourceElement() + session = this@JavaSymbolProvider.session + symbol = FirFieldSymbol(fieldId) + name = fieldName + visibility = javaField.visibility + modality = javaField.modality + returnTypeRef = returnType.toFirJavaTypeRef(this@JavaSymbolProvider.session, javaTypeParameterStack) + isVar = !javaField.isFinal + isStatic = javaField.isStatic + isEnumEntry = javaField.isEnumEntry + addAnnotationsFrom(this@JavaSymbolProvider.session, javaField, javaTypeParameterStack) + } } - declarations += firJavaField + declarations += firJavaDeclaration } for (javaMethod in javaClass.methods) { val methodName = javaMethod.name diff --git a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt index 073c2b3e144..6a2b83263e2 100644 --- a/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt +++ b/compiler/fir/java/src/org/jetbrains/kotlin/fir/java/enhancement/SignatureEnhancement.kt @@ -69,21 +69,22 @@ class FirSignatureEnhancement( name: Name ): FirVariableSymbol<*> { when (val firElement = original.fir) { - is FirField -> { + is FirEnumEntry -> { if (firElement.returnTypeRef !is FirJavaTypeRef) return original val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firElement.annotations) - val isEnumEntry = (firElement as? FirJavaField)?.isEnumEntry ?: false - - val predefinedInfo = if (isEnumEntry) { + val predefinedInfo = PredefinedFunctionEnhancementInfo( TypeEnhancementInfo(0 to JavaTypeQualifiers(NullabilityQualifier.NOT_NULL, null, false)), emptyList() ) - } else { - null - } val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, predefinedInfo) + return firElement.symbol.apply { this.fir.replaceReturnTypeRef(newReturnTypeRef) } + } + is FirField -> { + if (firElement.returnTypeRef !is FirJavaTypeRef) return original + val memberContext = context.copyWithNewDefaultTypeQualifiers(typeQualifierResolver, jsr305State, firElement.annotations) + val newReturnTypeRef = enhanceReturnType(firElement, emptyList(), memberContext, null) val symbol = FirFieldSymbol(original.callableId) buildJavaField { diff --git a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt index 9abafd3e060..c7ba2c44b34 100644 --- a/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt +++ b/compiler/fir/tree/src/org/jetbrains/kotlin/fir/FirRenderer.kt @@ -342,7 +342,6 @@ class FirRenderer(builder: StringBuilder, private val mode: RenderMode = RenderM } override fun visitEnumEntry(enumEntry: FirEnumEntry) { - enumEntry.annotations.renderAnnotations() visitCallableDeclaration(enumEntry) enumEntry.initializer?.let { print(" = ") diff --git a/compiler/testData/ir/irText/stubs/javaEnum.fir.txt b/compiler/testData/ir/irText/stubs/javaEnum.fir.txt index c342ca97b84..2d2b83d27cb 100644 --- a/compiler/testData/ir/irText/stubs/javaEnum.fir.txt +++ b/compiler/testData/ir/irText/stubs/javaEnum.fir.txt @@ -2,7 +2,7 @@ FILE fqName: fileName:/javaEnum.kt PROPERTY name:test visibility:public modality:FINAL [val] FIELD PROPERTY_BACKING_FIELD name:test type:.JEnum visibility:private [final,static] EXPRESSION_BODY - GET_FIELD 'FIELD IR_EXTERNAL_JAVA_DECLARATION_STUB name:ONE type:.JEnum visibility:public [final,static]' type=.JEnum origin=GET_PROPERTY + GET_ENUM 'ENUM_ENTRY IR_EXTERNAL_JAVA_DECLARATION_STUB name:ONE' type=.JEnum FUN DEFAULT_PROPERTY_ACCESSOR name: visibility:public modality:FINAL <> () returnType:.JEnum correspondingProperty: PROPERTY name:test visibility:public modality:FINAL [val] BLOCK_BODY diff --git a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt index 79e7c951286..d8ec5fbc8df 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/AnnotatedEnumEntry.fir.txt @@ -1,10 +1,7 @@ public final enum class AnnotatedEnumEntry : R|kotlin/Enum!>| { - @R|test/AnnotatedEnumEntry.Anno|(String(a)) public final static field E1: R|test/AnnotatedEnumEntry| - - @R|test/AnnotatedEnumEntry.Anno|(String(b)) @R|test/AnnotatedEnumEntry.Anno2|() public final static field E2: R|test/AnnotatedEnumEntry| - - public final static field E3: R|test/AnnotatedEnumEntry| - + @R|test/AnnotatedEnumEntry.Anno|(String(a)) public final static enum entry E1: R|test/AnnotatedEnumEntry| + @R|test/AnnotatedEnumEntry.Anno|(String(b)) @R|test/AnnotatedEnumEntry.Anno2|() public final static enum entry E2: R|test/AnnotatedEnumEntry| + public final static enum entry E3: R|test/AnnotatedEnumEntry| public final static fun values(): R|kotlin/Array| { } diff --git a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt index 063e0684ad1..7c9938b9448 100644 --- a/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt +++ b/compiler/testData/loadJava/compiledJava/annotations/EnumConstructorParameter.fir.txt @@ -1,6 +1,5 @@ public final enum class EnumConstructorParameter : R|kotlin/Enum!>| { - public final static field INSTANCE: R|test/EnumConstructorParameter| - + public final static enum entry INSTANCE: R|test/EnumConstructorParameter| private constructor(@R|test/EnumConstructorParameter.Anno|(String(string)) s: R|ft!|): R|test/EnumConstructorParameter| private constructor(x: R|kotlin/Int|): R|test/EnumConstructorParameter| diff --git a/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt b/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt index 2a104cd13f0..a07ec085ca8 100644 --- a/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt +++ b/compiler/testData/loadJava/compiledJava/enum/EnumMembers.fir.txt @@ -1,8 +1,6 @@ public final enum class EnumMembers : R|kotlin/Enum!>| { - public final static field FIRST: R|test/EnumMembers| - - public final static field SECOND: R|test/EnumMembers| - + public final static enum entry FIRST: R|test/EnumMembers| + public final static enum entry SECOND: R|test/EnumMembers| public final field isFirst: R|kotlin/Boolean| public open fun first(): R|kotlin/Boolean| diff --git a/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt b/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt index e725afd41ab..39db0096dde 100644 --- a/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt +++ b/compiler/testData/loadJava/compiledJava/enum/EnumWithSpecializedEntry.fir.txt @@ -1,8 +1,6 @@ public open enum class EnumWithSpecializedEntry : R|kotlin/Enum!>| { - public final static field E1: R|test/EnumWithSpecializedEntry| - - public final static field E2: R|test/EnumWithSpecializedEntry| - + public final static enum entry E1: R|test/EnumWithSpecializedEntry| + public final static enum entry E2: R|test/EnumWithSpecializedEntry| public final static fun values(): R|kotlin/Array| { } diff --git a/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt b/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt index 8ba9441d88f..e955da73274 100644 --- a/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt +++ b/compiler/testData/loadJava/compiledJava/enum/JavaEnum.fir.txt @@ -1,8 +1,6 @@ public final enum class JavaEnum : R|kotlin/Enum!>| { - public final static field ENTRY: R|test/JavaEnum| - - public final static field ANOTHER: R|test/JavaEnum| - + public final static enum entry ENTRY: R|test/JavaEnum| + public final static enum entry ANOTHER: R|test/JavaEnum| public final static fun values(): R|kotlin/Array| { } diff --git a/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt b/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt index d9e2fa162ec..81184201694 100644 --- a/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt +++ b/compiler/testData/loadJava/compiledJava/static/Enum.fir.txt @@ -1,10 +1,7 @@ public final enum class Enum : R|kotlin/Enum!>| { - public final static field A: R|test/Enum| - - public final static field B: R|test/Enum| - - public final static field C: R|test/Enum| - + public final static enum entry A: R|test/Enum| + public final static enum entry B: R|test/Enum| + public final static enum entry C: R|test/Enum| public final static fun values(): R|kotlin/Array| { } diff --git a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt index a46622ba144..fe4c8213187 100644 --- a/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt +++ b/compiler/testData/loadJava/compiledJava/static/StaticMembersInEnum.fir.txt @@ -1,6 +1,5 @@ public final enum class StaticMembersInEnum : R|kotlin/Enum!>| { - public final static field ENTRY: R|test/StaticMembersInEnum| - + public final static enum entry ENTRY: R|test/StaticMembersInEnum| public open static field STATIC_FIELD: R|kotlin/Int| public final static field CONSTANT: R|ft!|