[Test] Move KotlinAgainstKotlin tests under BlackBoxCodegen tests

2021-01-22 15:13:50 +03:00
parent 1ea4fa4464
commit 5c8d555808
147 changed files with 3749 additions and 2743 deletions
@@ -0,0 +1,20 @@
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: A.kt
+
+abstract class A {
+    private val x = object {
+        fun foo() = "OK"
+    }
+
+    protected val y = x.foo()
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+class B : A() {
+    val z = y
+}
+
+fun box() = B().z
@@ -0,0 +1,33 @@
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: A.kt
+
+interface KotlinMangler<D : Any> {
+    val String.hashMangle: Long
+    val D.fqnString: String
+    val D.fqnMangle: Long get() = fqnString.hashMangle
+    val manglerName: String
+
+    interface IrMangler : KotlinMangler<String> {
+        override val manglerName: String
+            get() = "Ir"
+    }
+}
+
+abstract class AbstractKotlinMangler<D : Any> : KotlinMangler<D> {
+    override val String.hashMangle get() = 42L
+}
+
+abstract class IrBasedKotlinManglerImpl : AbstractKotlinMangler<String>(), KotlinMangler.IrMangler {
+    override val String.fqnString: String
+        get() = this
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+abstract class AbstractJvmManglerIr : IrBasedKotlinManglerImpl()
+
+object JvmManglerIr : AbstractJvmManglerIr()
+
+fun box() = "OK"
@@ -0,0 +1,26 @@
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: A.kt
+// WITH_RUNTIME
+
+abstract class IncrementalCompilerRunner<T>(
+    private val workingDir: String,
+    val fail: Boolean,
+    val output: Collection<String> = emptyList()
+) {
+    fun res(res: T? = null): String = (res as? String) ?: (if (fail) "FAIL" else workingDir)
+}
+
+class IncrementalJsCompilerRunner(
+    private val workingDir: String,
+    fail: Boolean = true
+) : IncrementalCompilerRunner<String>(workingDir, fail) {
+}
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun box(): String {
+    val runner = IncrementalJsCompilerRunner(workingDir = "OK", fail = false)
+    return runner.res()
+}
@@ -0,0 +1,100 @@
+// IGNORE_BACKEND_FIR: JVM_IR
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: A.kt
+// WITH_RUNTIME
+
+abstract class IrConst<T> : IrExpression(), IrExpressionWithCopy {
+    abstract val kind: IrConstKind<T>
+    abstract val value: T
+
+    abstract override fun copy(): IrConst<T>
+    abstract fun copyWithOffsets(startOffset: Int, endOffset: Int): IrConst<T>
+}
+
+sealed class IrConstKind<T>(val asString: kotlin.String) {
+    @Suppress("UNCHECKED_CAST")
+    fun valueOf(aConst: IrConst<*>) =
+        (aConst as IrConst<T>).value
+
+    object Null : IrConstKind<Nothing?>("Null")
+    object Boolean : IrConstKind<kotlin.Boolean>("Boolean")
+    object Char : IrConstKind<kotlin.Char>("Char")
+    object Byte : IrConstKind<kotlin.Byte>("Byte")
+    object Short : IrConstKind<kotlin.Short>("Short")
+    object Int : IrConstKind<kotlin.Int>("Int")
+    object Long : IrConstKind<kotlin.Long>("Long")
+    object String : IrConstKind<kotlin.String>("String")
+    object Float : IrConstKind<kotlin.Float>("Float")
+    object Double : IrConstKind<kotlin.Double>("Double")
+
+    override fun toString() = asString
+}
+
+interface IrType
+
+abstract class IrExpression : IrElementBase(), IrStatement, IrVarargElement, IrAttributeContainer {
+    @Suppress("LeakingThis")
+    override var attributeOwnerId: IrAttributeContainer = this
+
+    abstract var type: IrType
+
+    override fun <D> transform(transformer: IrElementTransformer<D>, data: D): IrExpression =
+        accept(transformer, data) as IrExpression
+
+    override fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D) {
+        // No children by default
+    }
+
+    override fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D) {
+        // No children by default
+    }
+}
+
+interface IrExpressionWithCopy {
+    fun copy(): IrExpression
+}
+
+interface IrAttributeContainer : IrElement {
+    var attributeOwnerId: IrAttributeContainer
+}
+
+abstract class IrElementBase : IrElement
+
+interface IrStatement : IrElement
+
+interface IrVarargElement : IrElement
+
+interface IrElement {
+    val startOffset: Int
+    val endOffset: Int
+
+    fun <R, D> accept(visitor: IrElementVisitor<R, D>, data: D): R
+
+    fun <D> acceptChildren(visitor: IrElementVisitor<Unit, D>, data: D): Unit
+
+    fun <D> transform(transformer: IrElementTransformer<D>, data: D): IrElement =
+        accept(transformer, data)
+
+    fun <D> transformChildren(transformer: IrElementTransformer<D>, data: D): Unit
+}
+
+interface IrElementVisitor<out R, in D>
+
+interface IrElementTransformer<in D> : IrElementVisitor<IrElement, D>
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+fun foo(cases: Collection<IrConst<*>>, exprTransformer: IrElementTransformer<Any>, context: Any) {
+    cases.map {
+        it.accept(exprTransformer, context)
+    }
+}
+
+fun box(): String {
+    return "OK"
+}
+
+
+
@@ -0,0 +1,23 @@
+// TARGET_BACKEND: JVM
+// MODULE: lib
+// FILE: A.kt
+// WITH_RUNTIME
+
+package first.second
+
+class FqName(val s: String)
+
+@JvmField
+val VOLATILE_ANNOTATION_FQ_NAME = FqName("volatile")
+
+// MODULE: main(lib)
+// FILE: B.kt
+
+import first.second.VOLATILE_ANNOTATION_FQ_NAME
+import first.second.FqName
+
+fun foo() = hasAnnotation(VOLATILE_ANNOTATION_FQ_NAME)
+
+fun hasAnnotation(name: FqName): Boolean = true
+
+fun box() = if (foo()) "OK" else "FAIL"