[Serialization] Add DiagnosticsTests for FIR

plugins/kotlinx-serialization/testData/diagnostics/DuplicateSerialName.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+
+@Serializable
+open class Parent(open val arg: Int)
+
+@Serializable
+class Derived(override val arg: Int): Parent(arg)

plugins/kotlinx-serialization/testData/diagnostics/EnumDuplicateSerialName.fir.kt

@@ -0,0 +1,29 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// SKIP_TXT
+import kotlinx.serialization.*
+
+
+@Serializable
+enum class ImplicitlyDuplicated {
+    @SerialName("foo")
+    FIRST,
+    @SerialName("foo")
+    SECOND
+}
+
+@Serializable
+enum class ExplicitlyDuplicated {
+    FIRST,
+    SECOND,
+    @SerialName("FIRST")
+    THIRD
+}
+
+@Serializable
+enum class ReversedExplicitlyDuplicated {
+    @SerialName("THIRD")
+    FIRST,
+    SECOND,
+    THIRD
+}

plugins/kotlinx-serialization/testData/diagnostics/ExternalSerializers.fir.fail

@@ -0,0 +1,3 @@
+An operation is not implemented: Support @Serializer(for=...) supertype generation
+kotlin.NotImplementedError: An operation is not implemented: Support @Serializer(for=...) supertype generation
+	at org.jetbrains.kotlinx.serialization.compiler.fir.SerializationFirSupertypesExtension.computeAdditionalSupertypes(SerializationFirSupertypesExtension.kt:39)

plugins/kotlinx-serialization/testData/diagnostics/ExternalSerializers.fir.kt

@@ -0,0 +1,10 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE, -OPT_IN_USAGE
+// SKIP_TXT
+
+// FILE: test.kt
+import kotlinx.serialization.*
+
+class Foo(i: Int, val j: Int)
+
+@Serializer(forClass = Foo::class)
+object ExternalSerializer

plugins/kotlinx-serialization/testData/diagnostics/IncorrectTransient.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// SKIP_TXT
+
+import kotlinx.serialization.Serializable
+import java.io.Serializable as JavaSerializable
+
+@Serializable
+class Data(val x: Int, @Transient val y: String)
+
+@Serializable
+class Data2(val x: Int, @Transient val y: String) : JavaSerializable

plugins/kotlinx-serialization/testData/diagnostics/IncorrectTransient2.fir.kt

@@ -0,0 +1,20 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// SKIP_TXT
+
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.Transient
+import java.io.Serializable as JavaSerializable
+import kotlin.jvm.Transient as JavaTransient
+
+@Serializable
+class Data(val x: Int, @Transient val y: String = "a")
+
+@Serializable
+class Data2(val x: Int, @Transient val y: String = "a") : JavaSerializable
+
+@Serializable
+class Data3(val x: Int, @Transient @JavaTransient val y: String = "a") : JavaSerializable
+
+@Serializable
+class Data4(val x: Int, @JavaTransient val y: String)

plugins/kotlinx-serialization/testData/diagnostics/InheritableInfo.kt

@@ -1,3 +1,4 @@
+// FIR_IDENTICAL
 // !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
 // WITH_STDLIB
 // SKIP_TXT

plugins/kotlinx-serialization/testData/diagnostics/LazyRecursionBug.fir.kt

@@ -0,0 +1,10 @@
+// This test enshures that analysis ends up without compiler exceptions
+// !DIAGNOSTICS: -OPT_IN_USAGE
+
+import kotlinx.serialization.*
+
+@Serializable
+class Digest() {
+    @<!OPT_IN_USAGE_ERROR!>Serializer<!>(forClass = Digest::class)
+    companion <!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object<!> : KSerializer<Digest> {}
+}

plugins/kotlinx-serialization/testData/diagnostics/LocalAndAnonymous.fir.kt

@@ -0,0 +1,47 @@
+// !DIAGNOSTICS: -OPT_IN_USAGE_ERROR, -OPT_IN_USAGE
+// WITH_STDLIB
+// SKIP_TXT
+
+import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+
+fun container() {
+    @Serializable
+    class X // local classes are allowed
+
+    val y = @Serializable object {
+        fun inObjectFun() {
+            @Serializable
+            class X // local classes in anonymous object functions are not allowed
+        }
+    }
+
+
+    class LocalSerializer : KSerializer<Any?> {
+        override val descriptor: SerialDescriptor = buildSerialDescriptor("tmp", PrimitiveKind.INT)
+        override fun serialize(encoder: Encoder, value: Any?) {
+            encoder.encodeNull()
+        }
+
+        override fun deserialize(decoder: Decoder): Any? {
+            return decoder.decodeNull()
+        }
+    }
+
+    @Serializable
+    class WithLocalSerializerInProperty(@Serializable(with = LocalSerializer::class) val x: Any?)
+
+    @Serializable(with = LocalSerializer::class)
+    data class WithLocalSerializer(val i: Int)
+}
+
+val topLevelAnon = @Serializable object {}
+
+@Serializable class A {
+    @Serializable class B // nested classes are allowed
+
+    @Serializable inner class C // inner classes are not
+
+    @Serializable object F {} // regular named object, OK
+}

plugins/kotlinx-serialization/testData/diagnostics/NoSuitableCtorInParent.fir.kt

@@ -0,0 +1,9 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+
+open class NonSerializableParent(val arg: Int)
+
+@Serializable
+class Derived(val someData: String): NonSerializableParent(42)

plugins/kotlinx-serialization/testData/diagnostics/NonSerializable.fir.kt

@@ -0,0 +1,17 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+
+class NonSerializable
+
+@Serializable
+class Basic(val foo: NonSerializable)
+
+@Serializable
+class Inside(val foo: List<NonSerializable>)
+
+@Serializable
+class WithImplicitType {
+    val foo = NonSerializable()
+}

plugins/kotlinx-serialization/testData/diagnostics/NullabilityIncompatible.fir.kt

@@ -0,0 +1,17 @@
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+
+@Serializable(NopeNullableSerializer::class)
+class Nope {}
+
+class NopeNullableSerializer: KSerializer<Nope?> {
+    override val descriptor: SerialDescriptor get() = TODO()
+    override fun deserialize(decoder: Decoder): Nope? = TODO()
+    override fun serialize(encoder: Encoder, value: Nope?) = TODO()
+}
+
+@Serializable
+class Foo(val foo: Nope)

plugins/kotlinx-serialization/testData/diagnostics/ParamIsNotProperty.fir.kt

@@ -0,0 +1,7 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+
+@Serializable
+class Test(val someData: String, cantBeDeserialized: Int)

plugins/kotlinx-serialization/testData/diagnostics/SerializableEnums.fir.kt

@@ -0,0 +1,24 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+import kotlinx.serialization.encoding.*
+
+enum class SimpleEnum { A, B }
+
+enum class MarkedNameEnum { @SerialName("a") A, B}
+
+@Serializable
+enum class ExplicitlyMarkedEnum { @SerialName("a") A, B}
+
+@Serializable(EnumSerializer::class)
+enum class ExplicitlyMarkedEnumCustom { @SerialName("a") A, B}
+
+object EnumSerializer: KSerializer<ExplicitlyMarkedEnumCustom> {
+    override val descriptor = TODO()
+    override fun serialize(encoder: Encoder, value: ExplicitlyMarkedEnumCustom) = TODO()
+    override fun deserialize(decoder: Decoder): ExplicitlyMarkedEnumCustom = TODO()
+}
+
+@Serializable
+data class EnumUsage(val s: SimpleEnum, val m: MarkedNameEnum, val e: ExplicitlyMarkedEnum)

plugins/kotlinx-serialization/testData/diagnostics/SerializableIgnored.fir.kt

@@ -0,0 +1,11 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// SKIP_TXT
+
+// FILE: test.kt
+import kotlinx.serialization.*
+
+@Serializable
+interface INonSerializable
+
+@Serializable
+sealed interface SealedSerializable

plugins/kotlinx-serialization/testData/diagnostics/SerializerTypeCompatibleForSpecials.fir.kt

@@ -0,0 +1,19 @@
+// !DIAGNOSTICS: -OPT_IN_USAGE
+// WITH_STDLIB
+// SKIP_TXT
+
+import kotlinx.serialization.*
+
+class Bar
+@Serializer(forClass = Bar::class)
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object BarSerializer<!>: KSerializer<Bar>
+
+class Baz
+@Serializer(forClass = Baz::class)
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object BazSerializer<!>: KSerializer<Baz>
+
+@Serializable
+class Foo1(@Polymorphic val i: Baz)
+
+@Serializable
+class Foo2(val li: MutableList<@Serializable(with = BazSerializer::class) Baz>)

plugins/kotlinx-serialization/testData/diagnostics/SerializerTypeIncompatible.fir.kt

@@ -0,0 +1,39 @@
+// !DIAGNOSTICS: -OPT_IN_USAGE
+// WITH_STDLIB
+// SKIP_TXT
+
+import kotlinx.serialization.*
+
+class Bar
+@Serializer(forClass = Bar::class)
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object BarSerializer<!>: KSerializer<Bar>
+
+class Baz
+@Serializer(forClass = Baz::class)
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object BazSerializer<!>: KSerializer<Baz>
+@Serializer(forClass = Baz::class)
+<!ABSTRACT_MEMBER_NOT_IMPLEMENTED!>object NullableBazSerializer<!>: KSerializer<Baz?>
+
+@Serializable(with = BazSerializer::class)
+class Biz(val i: Int)
+
+@Serializable
+class Foo(@Serializable(with = BazSerializer::class) val i: Bar)
+
+@Serializable
+class Foo2(val li: List<@Serializable(with = BazSerializer::class) Bar>)
+
+@Serializable
+class Foo3(@Serializable(with = BazSerializer::class) val i: Baz)
+
+@Serializable
+class Foo4(val li: List<@Serializable(with = BazSerializer::class) Baz>)
+
+@Serializable
+class Foo5(@Serializable(with = BazSerializer::class) val i: Bar?)
+
+@Serializable
+class Foo6(@Serializable(with = NullableBazSerializer::class) val i: Bar)
+
+@Serializable
+class Foo7(@Serializable(with = NullableBazSerializer::class) val i: Bar?)

plugins/kotlinx-serialization/testData/diagnostics/Transients.fir.kt

@@ -0,0 +1,12 @@
+// !DIAGNOSTICS: -UNUSED_PARAMETER,-UNUSED_VARIABLE
+// WITH_STDLIB
+// FILE: test.kt
+import kotlinx.serialization.*
+
+@Serializable
+data class WithTransients(@Transient val missing: Int) {
+    @Transient val redundant: Int get() = 42
+
+    @Transient
+    lateinit var allowTransientLateinitWithoutInitializer: String
+}

plugins/kotlinx-serialization/tests-gen/org/jetbrains/kotlinx/serialization/runners/SerializationFirDiagnosticTestGenerated.java

@@ -0,0 +1,195 @@
+/*
+ * Copyright 2010-2022 JetBrains s.r.o. and Kotlin Programming Language contributors.
+ * Use of this source code is governed by the Apache 2.0 license that can be found in the license/LICENSE.txt file.
+ */
+
+package org.jetbrains.kotlinx.serialization.runners;
+
+import com.intellij.testFramework.TestDataPath;
+import org.jetbrains.kotlin.test.util.KtTestUtil;
+import org.jetbrains.kotlin.test.TestMetadata;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import java.io.File;
+import java.util.regex.Pattern;
+
+/** This class is generated by {@link GenerateNewCompilerTests.kt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+public class SerializationFirDiagnosticTestGenerated extends AbstractSerializationFirDiagnosticTest {
+    @Nested
+    @TestMetadata("plugins/kotlinx-serialization/testData/diagnostics")
+    @TestDataPath("$PROJECT_ROOT")
+    public class Diagnostics {
+        @Test
+        public void testAllFilesPresentInDiagnostics() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlinx-serialization/testData/diagnostics"), Pattern.compile("^(.+)\\.kt$"), Pattern.compile("^(.+)\\.fir\\.kts?$"), true);
+        }
+
+        @Test
+        @TestMetadata("DuplicateSerialName.kt")
+        public void testDuplicateSerialName() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/DuplicateSerialName.kt");
+        }
+
+        @Test
+        @TestMetadata("EnumDuplicateSerialName.kt")
+        public void testEnumDuplicateSerialName() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/EnumDuplicateSerialName.kt");
+        }
+
+        @Test
+        @TestMetadata("ExternalSerializers.kt")
+        public void testExternalSerializers() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/ExternalSerializers.kt");
+        }
+
+        @Test
+        @TestMetadata("IncorrectTransient.kt")
+        public void testIncorrectTransient() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/IncorrectTransient.kt");
+        }
+
+        @Test
+        @TestMetadata("IncorrectTransient2.kt")
+        public void testIncorrectTransient2() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/IncorrectTransient2.kt");
+        }
+
+        @Test
+        @TestMetadata("InheritableInfo.kt")
+        public void testInheritableInfo() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/InheritableInfo.kt");
+        }
+
+        @Test
+        @TestMetadata("LazyRecursionBug.kt")
+        public void testLazyRecursionBug() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/LazyRecursionBug.kt");
+        }
+
+        @Test
+        @TestMetadata("LocalAndAnonymous.kt")
+        public void testLocalAndAnonymous() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/LocalAndAnonymous.kt");
+        }
+
+        @Test
+        @TestMetadata("NoSuitableCtorInParent.kt")
+        public void testNoSuitableCtorInParent() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/NoSuitableCtorInParent.kt");
+        }
+
+        @Test
+        @TestMetadata("NonSerializable.kt")
+        public void testNonSerializable() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/NonSerializable.kt");
+        }
+
+        @Test
+        @TestMetadata("NullabilityIncompatible.kt")
+        public void testNullabilityIncompatible() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/NullabilityIncompatible.kt");
+        }
+
+        @Test
+        @TestMetadata("ParamIsNotProperty.kt")
+        public void testParamIsNotProperty() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/ParamIsNotProperty.kt");
+        }
+
+        @Test
+        @TestMetadata("SerializableEnums.kt")
+        public void testSerializableEnums() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/SerializableEnums.kt");
+        }
+
+        @Test
+        @TestMetadata("SerializableIgnored.kt")
+        public void testSerializableIgnored() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/SerializableIgnored.kt");
+        }
+
+        @Test
+        @TestMetadata("SerializerTypeCompatibleForSpecials.kt")
+        public void testSerializerTypeCompatibleForSpecials() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/SerializerTypeCompatibleForSpecials.kt");
+        }
+
+        @Test
+        @TestMetadata("SerializerTypeIncompatible.kt")
+        public void testSerializerTypeIncompatible() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/SerializerTypeIncompatible.kt");
+        }
+
+        @Test
+        @TestMetadata("Transients.kt")
+        public void testTransients() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/diagnostics/Transients.kt");
+        }
+    }
+
+    @Nested
+    @TestMetadata("plugins/kotlinx-serialization/testData/firMembers")
+    @TestDataPath("$PROJECT_ROOT")
+    public class FirMembers {
+        @Test
+        @TestMetadata("abstractAndSealed.kt")
+        public void testAbstractAndSealed() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/abstractAndSealed.kt");
+        }
+
+        @Test
+        public void testAllFilesPresentInFirMembers() throws Exception {
+            KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("plugins/kotlinx-serialization/testData/firMembers"), Pattern.compile("^(.+)\\.kt$"), null, true);
+        }
+
+        @Test
+        @TestMetadata("classWithCompanionObject.kt")
+        public void testClassWithCompanionObject() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/classWithCompanionObject.kt");
+        }
+
+        @Test
+        @TestMetadata("classWithGenericParameters.kt")
+        public void testClassWithGenericParameters() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/classWithGenericParameters.kt");
+        }
+
+        @Test
+        @TestMetadata("defaultProperties.kt")
+        public void testDefaultProperties() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/defaultProperties.kt");
+        }
+
+        @Test
+        @TestMetadata("enums.kt")
+        public void testEnums() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/enums.kt");
+        }
+
+        @Test
+        @TestMetadata("inlineClasses.kt")
+        public void testInlineClasses() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/inlineClasses.kt");
+        }
+
+        @Test
+        @TestMetadata("multipleProperties.kt")
+        public void testMultipleProperties() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/multipleProperties.kt");
+        }
+
+        @Test
+        @TestMetadata("privatePropertiesSerialization.kt")
+        public void testPrivatePropertiesSerialization() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/privatePropertiesSerialization.kt");
+        }
+
+        @Test
+        @TestMetadata("serializableObject.kt")
+        public void testSerializableObject() throws Exception {
+            runTest("plugins/kotlinx-serialization/testData/firMembers/serializableObject.kt");
+        }
+    }
+}

plugins/kotlinx-serialization/tests/org/jetbrains/kotlinx/serialization/TestGenerator.kt

@@ -23,6 +23,11 @@ fun main(args: Array<String>) {
                 model("diagnostics", excludedPattern = excludedFirTestdataPattern)
             }
 
+            testClass<AbstractSerializationFirDiagnosticTest> {
+                model("diagnostics", excludedPattern = excludedFirTestdataPattern)
+                model("firMembers")
+            }
+
             // ------------------------------- asm instructions -------------------------------
 
             testClass<AbstractSerializationAsmLikeInstructionsListingTest> {

plugins/kotlinx-serialization/tests/org/jetbrains/kotlinx/serialization/runners/AsmLikeInstructionsListingTests.kt

@@ -8,6 +8,7 @@ package org.jetbrains.kotlinx.serialization.runners
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
 import org.jetbrains.kotlin.test.directives.AsmLikeInstructionListingDirectives
 import org.jetbrains.kotlin.test.runners.codegen.AbstractAsmLikeInstructionListingTest
+import org.jetbrains.kotlin.test.runners.codegen.AbstractFirAsmLikeInstructionListingTest
 import org.jetbrains.kotlin.test.runners.codegen.AbstractIrAsmLikeInstructionListingTest
 import org.jetbrains.kotlinx.serialization.configureForKotlinxSerialization
 

plugins/kotlinx-serialization/tests/org/jetbrains/kotlinx/serialization/runners/DiagnosticTests.kt

@@ -6,7 +6,10 @@
 package org.jetbrains.kotlinx.serialization.runners
 
 import org.jetbrains.kotlin.test.builders.TestConfigurationBuilder
+import org.jetbrains.kotlin.test.directives.FirDiagnosticsDirectives.FIR_DUMP
 import org.jetbrains.kotlin.test.runners.AbstractDiagnosticTest
+import org.jetbrains.kotlin.test.runners.AbstractFirDiagnosticTest
+import org.jetbrains.kotlin.test.runners.configurationForClassicAndFirTestsAlongside
 import org.jetbrains.kotlinx.serialization.configureForKotlinxSerialization
 
 abstract class AbstractSerializationPluginDiagnosticTest : AbstractDiagnosticTest() {
@@ -15,3 +18,22 @@ abstract class AbstractSerializationPluginDiagnosticTest : AbstractDiagnosticTes
         builder.configureForKotlinxSerialization()
     }
 }
+
+abstract class AbstractSerializationFirDiagnosticTest : AbstractFirDiagnosticTest() {
+    override fun configure(builder: TestConfigurationBuilder) {
+        super.configure(builder)
+        with(builder) {
+            configureForKotlinxSerialization()
+
+            forTestsMatching("*/diagnostics/*") {
+                configurationForClassicAndFirTestsAlongside()
+            }
+
+            forTestsMatching("*/firMembers/*") {
+                defaultDirectives {
+                    +FIR_DUMP
+                }
+            }
+        }
+    }
+}