[KLIB] API for dumping KLIB ABI

^KT-54402

.idea/runConfigurations/Generate_Compiler_Tests.xml

@@ -13,10 +13,11 @@
           <option value=":compiler:tests-for-compiler-generator:generateTests" />
           <option value=":compiler:tests-java8:generateTests" />
           <option value=":compiler:tests-against-klib:generateTests" />
+          <option value=":core:descriptors.runtime:generateTests" />
           <option value=":js:js.tests:generateTests" />
           <option value=":native:native.tests:generateTests" />
-          <option value=":core:descriptors.runtime:generateTests" />
           <option value=":wasm:wasm.tests:generateTests" />
+          <option value=":kotlin-util-klib-abi:generateTests" />
         </list>
       </option>
       <option name="vmOptions" value="" />

build.gradle.kts

@@ -195,6 +195,7 @@ val fe10CompilerModules = arrayOf(
     ":kotlin-util-io",
     ":kotlin-util-klib",
     ":kotlin-util-klib-metadata",
+    ":kotlin-util-klib-abi",
     ":compiler:backend-common",
     ":compiler:backend",
     ":compiler:plugin-api",
@@ -745,6 +746,7 @@ tasks {
         dependsOn(":core:descriptors.runtime:test")
         dependsOn(":kotlin-util-io:test")
         dependsOn(":kotlin-util-klib:test")
+        dependsOn(":kotlin-util-klib-abi:test")
         dependsOn(":generators:test")
     }
 

compiler/util-klib-abi/ReadMe.md

@@ -0,0 +1,7 @@
+## API for extracting publicly visible ABI from KLIBs
+
+This is the API to extract and dump declarations from KLIBs that comprise publicly visible part of KLIB ABI. Can be used for implementing various KLIB-oriented build tools that do ABI compatibility validation, perform compilation avoidance with KLIBs, etc.
+
+There are two major entry points:
+* [LibraryAbiReader](src/org/jetbrains/kotlin/library/abi/LibraryAbiReader.kt) - extracts publicly visible ABI
+* [LibraryAbiRenderer](src/org/jetbrains/kotlin/library/abi/LibraryAbiRenderer.kt) - renders it to a human-readable textual representation

compiler/util-klib-abi/build.gradle.kts

@@ -0,0 +1,38 @@
+plugins {
+    kotlin("jvm")
+    id("jps-compatible")
+}
+
+dependencies {
+    api(kotlinStdlib())
+    implementation(project(":kotlin-util-klib"))
+    implementation(project(":core:compiler.common"))
+    implementation(project(":compiler:ir.serialization.common"))
+    compileOnly(commonDependency("org.jetbrains.intellij.deps.fastutil:intellij-deps-fastutil"))
+    testApiJUnit5()
+    testImplementation(intellijCore())
+    testImplementation(commonDependency("org.jetbrains.kotlin:kotlin-reflect")) { isTransitive = false }
+    testImplementation(projectTests(":compiler:tests-common-new"))
+    testImplementation(projectTests(":generators:test-generator"))
+}
+
+sourceSets {
+    "main" { projectDefault() }
+    "test" {
+        projectDefault()
+        generatedTestDir()
+    }
+}
+
+val testDataDir = projectDir.resolve("testData")
+
+projectTest(jUnitMode = JUnitMode.JUnit5) {
+    inputs.dir(testDataDir)
+    outputs.dir("$buildDir/t")
+
+    dependsOn(":dist")
+    workingDir = rootDir
+    useJUnitPlatform()
+}
+
+val generateTests by generator("org.jetbrains.kotlin.library.abi.GenerateLibraryAbiReaderTestsKt")

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/ExperimentalLibraryAbiReader.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+/**
+ * This marker distinguishes the experimental Kotlin library ABI reader API and is used to opt-in.
+ *
+ * Any usage of a declaration annotated with `@ExperimentalLibraryAbiReader` must be accepted either by
+ * annotating that usage with the [OptIn] annotation, e.g. `@OptIn(ExperimentalLibraryAbiReader::class)`,
+ * or by using the compiler argument `-opt-in=org.jetbrains.kotlin.library.abi.ExperimentalLibraryAbiReader`.
+ */
+@RequiresOptIn
+annotation class ExperimentalLibraryAbiReader

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/LibraryAbi.kt

@@ -0,0 +1,284 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+/**
+ * The result of reading ABI from KLIB.
+ *
+ * @property manifest Information from the manifest that may be useful.
+ * @property uniqueName The library's unique name that is a part of the library ABI.
+ *   Corresponds to the `unique_name` manifest property.
+ * @property signatureVersions The versions of signatures supported by the KLIB. Note that not every [AbiSignatureVersion]
+ *   which is supported by the KLIB is also supported by the ABI reader. To check this please use
+ *   [AbiSignatureVersion.isSupportedByAbiReader]. An attempt to obtain a signature of unsupported version will result
+ *   in an exception. See also [AbiSignatures.get].
+ * @property topLevelDeclarations The list of top-level declarations.
+ */
+@ExperimentalLibraryAbiReader
+class LibraryAbi(
+    val manifest: LibraryManifest,
+    val uniqueName: String,
+    val signatureVersions: Set<AbiSignatureVersion>,
+    val topLevelDeclarations: AbiTopLevelDeclarations
+)
+
+/**
+ * The representation of the version of IR signatures supported by a KLIB.
+ *
+ * @property versionNumber The unique version number of the IR signature.
+ * @property isSupportedByAbiReader Whether this IR signature version is supported by the current implementation of
+ *   the ABI reader. If it's not supported then such signatures can't be read by the ABI reader, and the version itself
+ *   just serves for information purposes.
+ * @property description Brief description of the IR signature version, if available. To be used purely for discovery
+ *   purposes by ABI reader clients. Warning: The description text may be freely changed in the future. So, it should
+ *   NEVER be used for making ABI snapshots.
+ */
+@ExperimentalLibraryAbiReader
+interface AbiSignatureVersion {
+    val versionNumber: Int
+    val isSupportedByAbiReader: Boolean
+    val description: String?
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiSignatures {
+    /**
+     * Returns the signature of the specified [AbiSignatureVersion].
+     *
+     * - If the signature version is not supported by the ABI reader (according to [AbiSignatureVersion.isSupportedByAbiReader])
+     *   then throw an exception.
+     * - If the signature version is supported by the ABI reader, but the signature is unavailable for some other reason
+     *   (e.g. a particular type of declaration misses a signature of a particular version), then return `null`.
+     **/
+    operator fun get(signatureVersion: AbiSignatureVersion): String?
+}
+
+/**
+ * Simple name.
+ * Examples: "TopLevelClass", "topLevelFun", "List", "EMPTY".
+ */
+@ExperimentalLibraryAbiReader
+@JvmInline
+value class AbiSimpleName(val value: String) : Comparable<AbiSimpleName> {
+    init {
+        require(AbiCompoundName.SEPARATOR !in value && AbiQualifiedName.SEPARATOR !in value) {
+            "Simple name contains illegal characters: $value"
+        }
+    }
+
+    override fun compareTo(other: AbiSimpleName) = value.compareTo(other.value)
+    override fun toString() = value
+}
+
+/**
+ * Compound name. An equivalent of one or more [AbiSimpleName]s which are concatenated with dots.
+ * Examples: "TopLevelClass", "topLevelFun", "List", "CharRange.Companion.EMPTY".
+ */
+@ExperimentalLibraryAbiReader
+@JvmInline
+value class AbiCompoundName(val value: String) : Comparable<AbiCompoundName> {
+    init {
+        require(AbiQualifiedName.SEPARATOR !in value) { "Compound name contains illegal characters: $value" }
+    }
+
+    val nameSegments: List<AbiSimpleName> get() = value.split(SEPARATOR).map(::AbiSimpleName)
+    val nameSegmentsCount: Int get() = value.count { it == SEPARATOR } + 1
+
+    val simpleName: AbiSimpleName get() = AbiSimpleName(value.substringAfterLast(SEPARATOR))
+
+    override fun compareTo(other: AbiCompoundName) = value.compareTo(other.value)
+    override fun toString() = value
+
+    infix fun isContainerOf(member: AbiCompoundName): Boolean {
+        val containerName = value
+        return when (val containerNameLength = containerName.length) {
+            0 -> true
+            else -> {
+                val memberName = member.value
+                val memberNameLength = memberName.length
+                memberNameLength > containerNameLength + 1 &&
+                        memberName.startsWith(containerName) &&
+                        memberName[containerNameLength] == SEPARATOR
+            }
+        }
+    }
+
+    companion object {
+        const val SEPARATOR = '.'
+    }
+}
+
+/**
+ * Fully qualified name.
+ * Examples: "/TopLevelClass", "/topLevelFun", "kotlin.collections/List", "kotlin.ranges/CharRange.Companion.EMPTY".
+ */
+@ExperimentalLibraryAbiReader
+data class AbiQualifiedName(val packageName: AbiCompoundName, val relativeName: AbiCompoundName) : Comparable<AbiQualifiedName> {
+    init {
+        require(relativeName.value.isNotEmpty()) { "Empty relative name" }
+    }
+
+    override fun compareTo(other: AbiQualifiedName): Int {
+        val diff = packageName.compareTo(other.packageName)
+        return if (diff != 0) diff else relativeName.compareTo(other.relativeName)
+    }
+
+    override fun toString() = "$packageName$SEPARATOR$relativeName"
+
+    companion object {
+        const val SEPARATOR = '/'
+    }
+}
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiDeclaration {
+    val qualifiedName: AbiQualifiedName
+    val signatures: AbiSignatures
+
+    /**
+     * Annotations are not a part of ABI. But sometimes it is useful to have the ability to check if some declaration
+     * has a specific annotation. See [AbiReadingFilter.NonPublicMarkerAnnotations] as an example.
+     */
+    fun hasAnnotation(annotationClassName: AbiQualifiedName): Boolean
+}
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiDeclarationWithModality : AbiDeclaration {
+    val modality: AbiModality
+}
+
+@ExperimentalLibraryAbiReader
+enum class AbiModality {
+    FINAL, OPEN, ABSTRACT, SEALED
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiDeclarationContainer {
+    /** Important: The order of declarations is preserved exactly as in serialized IR. */
+    val declarations: List<AbiDeclaration>
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiTopLevelDeclarations : AbiDeclarationContainer
+
+@ExperimentalLibraryAbiReader
+interface AbiClass : AbiDeclarationWithModality, AbiDeclarationContainer, AbiTypeParametersContainer {
+    val kind: AbiClassKind
+    val isInner: Boolean
+    val isValue: Boolean
+    val isFunction: Boolean
+
+    /**
+     * The set of non-trivial supertypes (i.e. excluding [kotlin.Any]).
+     * Important: The order of supertypes is preserved exactly as in serialized IR.
+     */
+    val superTypes: List<AbiType>
+}
+
+@ExperimentalLibraryAbiReader
+enum class AbiClassKind {
+    CLASS, INTERFACE, OBJECT, ENUM_CLASS, ANNOTATION_CLASS
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiEnumEntry : AbiDeclaration
+
+@ExperimentalLibraryAbiReader
+interface AbiFunction : AbiDeclarationWithModality, AbiTypeParametersContainer {
+    val isConstructor: Boolean
+    val isInline: Boolean
+    val isSuspend: Boolean
+    val hasExtensionReceiverParameter: Boolean
+    val contextReceiverParametersCount: Int
+
+    /**
+     * Important: All value parameters of the function are stored in the single place, in the [valueParameters] list in
+     * a well-defined order. First, unless [hasExtensionReceiverParameter] is false, goes the extension receiver parameter.
+     * It is followed by [contextReceiverParametersCount] context receiver parameters. The remainder are the regular
+     * value parameters of the function.
+     */
+    val valueParameters: List<AbiValueParameter>
+    val returnType: AbiType?
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiValueParameter {
+    val type: AbiType
+    val isVararg: Boolean
+    val hasDefaultArg: Boolean
+    val isNoinline: Boolean
+    val isCrossinline: Boolean
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiProperty : AbiDeclarationWithModality {
+    val kind: AbiPropertyKind
+    val getter: AbiFunction?
+    val setter: AbiFunction?
+}
+
+@ExperimentalLibraryAbiReader
+enum class AbiPropertyKind { VAL, CONST_VAL, VAR }
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiTypeParametersContainer : AbiDeclaration {
+    /** Important: The order of [typeParameters] is preserved exactly as in serialized IR. */
+    val typeParameters: List<AbiTypeParameter>
+}
+
+@ExperimentalLibraryAbiReader
+interface AbiTypeParameter {
+    val tag: String
+    val variance: AbiVariance
+    val isReified: Boolean
+
+    /**
+     * The set of non-trivial upper bounds (i.e. excluding nullable [kotlin.Any]).
+     * Important: The order of upper bounds is preserved exactly as in serialized IR.
+     */
+    val upperBounds: List<AbiType>
+}
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiType {
+    interface Dynamic : AbiType
+    interface Error : AbiType
+    interface Simple : AbiType {
+        val classifierReference: AbiClassifierReference
+        val arguments: List<AbiTypeArgument>
+        val nullability: AbiTypeNullability
+    }
+}
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiTypeArgument {
+    interface StarProjection : AbiTypeArgument
+    interface TypeProjection : AbiTypeArgument {
+        val type: AbiType
+        val variance: AbiVariance
+    }
+}
+
+@ExperimentalLibraryAbiReader
+sealed interface AbiClassifierReference {
+    interface ClassReference : AbiClassifierReference {
+        val className: AbiQualifiedName
+    }
+
+    interface TypeParameterReference : AbiClassifierReference {
+        val tag: String
+    }
+}
+
+@ExperimentalLibraryAbiReader
+enum class AbiTypeNullability {
+    MARKED_NULLABLE, NOT_SPECIFIED, DEFINITELY_NOT_NULL
+}
+
+@ExperimentalLibraryAbiReader
+enum class AbiVariance {
+    INVARIANT, IN, OUT
+}

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/LibraryAbiReader.kt

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.abi.impl.LibraryAbiReaderImpl
+import java.io.File
+
+/** The default implementation of [LibraryAbi] reader. */
+@ExperimentalLibraryAbiReader
+object LibraryAbiReader {
+    /** Inspect the KLIB at [library]. The KLIB can be either in a directory (unzipped) or in a file (zipped) form. */
+    fun readAbiInfo(library: File, vararg filters: AbiReadingFilter): LibraryAbi = readAbiInfo(library, filters.asList())
+    fun readAbiInfo(library: File, filters: List<AbiReadingFilter>): LibraryAbi = LibraryAbiReaderImpl(library, filters).readAbi()
+}
+
+/**
+ * Defines a filter for skipping certain [AbiDeclaration]s during reading the KLIB ABI.
+ *
+ * There are several ready-to-use implementations: [ExcludedPackages], [ExcludedClasses] and [NonPublicMarkerAnnotations].
+ * But also it's possible to implement your own filter if necessary.
+ */
+@ExperimentalLibraryAbiReader
+interface AbiReadingFilter {
+    fun isPackageExcluded(packageName: AbiCompoundName): Boolean = false
+    fun isDeclarationExcluded(declaration: AbiDeclaration): Boolean = false
+
+    class ExcludedPackages(excludedPackageNames: Collection<AbiCompoundName>) : AbiReadingFilter {
+        private val excludedPackageNames = excludedPackageNames.toSet()
+
+        override fun isPackageExcluded(packageName: AbiCompoundName) = when {
+            excludedPackageNames.isEmpty() -> false
+            packageName in excludedPackageNames -> true
+            else -> excludedPackageNames.any { excludedPackageName -> excludedPackageName isContainerOf packageName }
+        }
+    }
+
+    class ExcludedClasses(excludedClassNames: Collection<AbiQualifiedName>) : AbiReadingFilter {
+        private val excludedClassNames = excludedClassNames.toSet()
+
+        override fun isDeclarationExcluded(declaration: AbiDeclaration) =
+            declaration is AbiClass && declaration.qualifiedName in excludedClassNames
+    }
+
+    class NonPublicMarkerAnnotations(nonPublicMarkerNames: Collection<AbiQualifiedName>) : AbiReadingFilter {
+        private val nonPublicMarkerNames = nonPublicMarkerNames.toSet().toTypedArray()
+
+        override fun isDeclarationExcluded(declaration: AbiDeclaration): Boolean {
+            for (nonPublicMarkerName in nonPublicMarkerNames) {
+                if (declaration.hasAnnotation(nonPublicMarkerName)) return true
+            }
+            return false
+        }
+    }
+
+    class Composite(filters: List<AbiReadingFilter>) : AbiReadingFilter {
+        private val filters = filters.toTypedArray()
+
+        override fun isPackageExcluded(packageName: AbiCompoundName): Boolean {
+            for (filter in filters) {
+                if (filter.isPackageExcluded(packageName)) return true
+            }
+            return false
+        }
+
+        override fun isDeclarationExcluded(declaration: AbiDeclaration): Boolean {
+            for (filter in filters) {
+                if (filter.isDeclarationExcluded(declaration)) return true
+            }
+            return false
+        }
+    }
+}

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/LibraryAbiRenderer.kt

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.abi.impl.AbiRendererImpl
+
+/** The default rendering implementation. */
+@ExperimentalLibraryAbiReader
+object LibraryAbiRenderer {
+    fun render(libraryAbi: LibraryAbi, settings: AbiRenderingSettings): String =
+        buildString { render(libraryAbi, this, settings) }
+
+    fun render(libraryAbi: LibraryAbi, output: Appendable, settings: AbiRenderingSettings): Unit =
+        AbiRendererImpl(libraryAbi, settings, output).render()
+}
+
+/**
+ * @param renderedSignatureVersion The IR signature version to render. This should be a version among the versions
+ *   listed in [LibraryAbi.signatureVersions].
+ * @param renderManifest Whether KLIB manifest properties should be rendered.
+ * @param renderDeclarations Whether declarations should be rendered.
+ * @param indentationString The string used for indentation of nested declarations.
+ * @param whenSignatureNotFound A handler that is executed when a signature is not found for a specific declaration.
+ */
+@ExperimentalLibraryAbiReader
+class AbiRenderingSettings(
+    val renderedSignatureVersion: AbiSignatureVersion,
+    val renderManifest: Boolean = false,
+    val renderDeclarations: Boolean = true,
+    val indentationString: String = "    ",
+    val whenSignatureNotFound: (AbiDeclaration, AbiSignatureVersion) -> String = { declaration, signatureVersion ->
+        error("No signature $signatureVersion for ${declaration::class.java}, $declaration")
+    }
+)

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/LibraryManifest.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.*
+
+/**
+ * Anything that can be retrieved from manifest and that might be helpful to know about the inspected KLIB.
+ *
+ * @property platform [KLIB_PROPERTY_BUILTINS_PLATFORM]
+ * @property nativeTargets [KLIB_PROPERTY_NATIVE_TARGETS]
+ * @property compilerVersion [KLIB_PROPERTY_COMPILER_VERSION]
+ * @property abiVersion [KLIB_PROPERTY_ABI_VERSION]
+ * @property libraryVersion [KLIB_PROPERTY_LIBRARY_VERSION]
+ * @property irProviderName [KLIB_PROPERTY_IR_PROVIDER]
+ */
+@ExperimentalLibraryAbiReader
+data class LibraryManifest(
+    val platform: String?,
+    val nativeTargets: List<String>,
+    val compilerVersion: String?,
+    val abiVersion: String?,
+    val libraryVersion: String?,
+    val irProviderName: String?
+)

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/impl/FlagFieldEx.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi.impl
+
+import org.jetbrains.kotlin.metadata.deserialization.Flags.FlagField
+
+/** TODO: Think how to contribute it to [FlagField]. */
+internal abstract class FlagFieldEx<T>(val offset: Int, val bitWidth: Int) {
+    init {
+        require(offset >= 0) { "Invalid offset: $offset" }
+        require(bitWidth > 0) { "Invalid bit width: $bitWidth" }
+
+        val overflow = offset + bitWidth - Int.SIZE_BITS
+        require(overflow <= 0) { "Not enough bit space for storage. Offset=$offset, width=$bitWidth, overflow=$overflow." }
+    }
+
+    abstract fun get(flags: Int): T
+    abstract fun toFlags(value: T): Int
+
+    private val bitMask = (1 shl bitWidth) - 1
+
+    protected fun readSignificantBitsFromFlags(flags: Int): Int = (flags ushr offset) and bitMask
+
+    protected fun storeSignificantBitsAsFlags(value: Int): Int {
+        require((value ushr bitWidth) == 0) { "Not enough space to store $value" }
+        return value shl offset
+    }
+
+    class IntFlagFieldEx(offset: Int, bitWidth: Int) : FlagFieldEx<Int>(offset, bitWidth) {
+        override fun get(flags: Int): Int = readSignificantBitsFromFlags(flags)
+        override fun toFlags(value: Int): Int = storeSignificantBitsAsFlags(value)
+    }
+
+    class EnumFlagFieldEx<E : Enum<E>>(offset: Int, private val entries: Array<E>) : FlagFieldEx<E>(offset, computeBitWidth(entries)) {
+        override fun get(flags: Int): E = entries[readSignificantBitsFromFlags(flags)]
+        override fun toFlags(value: E): Int = storeSignificantBitsAsFlags(value.ordinal)
+
+        companion object {
+            private fun <E : Enum<E>> computeBitWidth(entries: Array<E>): Int {
+                require(entries.isNotEmpty()) { "No enum entries" }
+                return maxOf(1, Int.SIZE_BITS - entries.lastIndex.countLeadingZeroBits())
+            }
+        }
+    }
+
+    companion object {
+        fun intFirst(bitWidth: Int): FlagFieldEx<Int> = IntFlagFieldEx(0, bitWidth)
+        fun intAfter(previous: FlagField<*>, bitWidth: Int): FlagFieldEx<Int> = IntFlagFieldEx(previous.nextOffset, bitWidth)
+        fun intAfter(previous: FlagFieldEx<*>, bitWidth: Int): FlagFieldEx<Int> = IntFlagFieldEx(previous.nextOffset, bitWidth)
+
+        inline fun <reified E : Enum<E>> first(): FlagFieldEx<E> = EnumFlagFieldEx(0, enumValues())
+        inline fun <reified E : Enum<E>> after(previous: FlagField<*>): FlagFieldEx<E> = EnumFlagFieldEx(previous.nextOffset, enumValues())
+        inline fun <reified E : Enum<E>> after(previous: FlagFieldEx<*>): FlagFieldEx<E> = EnumFlagFieldEx(previous.nextOffset, enumValues())
+
+        private val FlagField<*>.nextOffset: Int get() = offset + bitWidth
+        private val FlagFieldEx<*>.nextOffset: Int get() = offset + bitWidth
+    }
+}

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/impl/LibraryAbiImpl.kt

@@ -0,0 +1,251 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi.impl
+
+import org.jetbrains.kotlin.library.abi.*
+import org.jetbrains.kotlin.library.abi.impl.AbiFunctionImpl.Companion.BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT
+import org.jetbrains.kotlin.metadata.deserialization.Flags.FlagField
+
+@ExperimentalLibraryAbiReader
+internal object AbiSignatureVersions {
+    enum class Supported(override val versionNumber: Int, override val description: String) : AbiSignatureVersion {
+        V1(1, "The signatures with hashes"),
+        V2(2, "The self-descriptive signatures (with mangled names)");
+
+        override val isSupportedByAbiReader get() = true
+    }
+
+    private data class Unsupported(override val versionNumber: Int) : AbiSignatureVersion {
+        override val isSupportedByAbiReader get() = false
+        override val description: String? get() = null
+    }
+
+    fun resolveByVersionNumber(versionNumber: Int): AbiSignatureVersion =
+        Supported.entries.firstOrNull { it.versionNumber == versionNumber } ?: Unsupported(versionNumber)
+}
+
+@ExperimentalLibraryAbiReader
+internal data class AbiSignaturesImpl(private val signatureV1: String?, private val signatureV2: String?) : AbiSignatures {
+    override operator fun get(signatureVersion: AbiSignatureVersion): String? = when (signatureVersion) {
+        is AbiSignatureVersions.Supported -> when (signatureVersion) {
+            AbiSignatureVersions.Supported.V1 -> signatureV1
+            AbiSignatureVersions.Supported.V2 -> signatureV2
+        }
+        else -> error("Unsupported signature version: $signatureVersion")
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiTopLevelDeclarationsImpl(
+    override val declarations: List<AbiDeclaration>
+) : AbiTopLevelDeclarations
+
+@ExperimentalLibraryAbiReader
+internal class AbiClassImpl(
+    override val qualifiedName: AbiQualifiedName,
+    override val signatures: AbiSignatures,
+    private val annotations: Set<AbiQualifiedName>,
+    modality: AbiModality,
+    kind: AbiClassKind,
+    isInner: Boolean,
+    isValue: Boolean,
+    isFunction: Boolean,
+    override val superTypes: List<AbiType>,
+    override val declarations: List<AbiDeclaration>,
+    override val typeParameters: List<AbiTypeParameter>
+) : AbiClass {
+    private val flags = IS_INNER.toFlags(isInner) or
+            IS_VALUE.toFlags(isValue) or
+            IS_FUNCTION.toFlags(isFunction) or
+            MODALITY.toFlags(modality) or
+            CLASS_KIND.toFlags(kind)
+
+    override val modality get() = MODALITY.get(flags)
+    override val kind get() = CLASS_KIND.get(flags)
+    override val isInner get() = IS_INNER.get(flags)
+    override val isValue get() = IS_VALUE.get(flags)
+    override val isFunction get() = IS_FUNCTION.get(flags)
+    override fun hasAnnotation(annotationClassName: AbiQualifiedName) = annotationClassName in annotations
+
+    companion object {
+        private val IS_INNER = FlagField.booleanFirst()
+        private val IS_VALUE = FlagField.booleanAfter(IS_INNER)
+        private val IS_FUNCTION = FlagField.booleanAfter(IS_VALUE)
+        private val MODALITY = FlagFieldEx.after<AbiModality>(IS_FUNCTION)
+        private val CLASS_KIND = FlagFieldEx.after<AbiClassKind>(MODALITY)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiEnumEntryImpl(
+    override val qualifiedName: AbiQualifiedName,
+    override val signatures: AbiSignatures,
+    private val annotations: Set<AbiQualifiedName>
+) : AbiEnumEntry {
+    override fun hasAnnotation(annotationClassName: AbiQualifiedName) = annotationClassName in annotations
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiConstructorImpl(
+    override val qualifiedName: AbiQualifiedName,
+    override val signatures: AbiSignatures,
+    private val annotations: Set<AbiQualifiedName>,
+    isInline: Boolean,
+    contextReceiverParametersCount: Int,
+    override val valueParameters: List<AbiValueParameter>
+) : AbiFunction {
+    private val flags = IS_INLINE.toFlags(isInline) or
+            CONTEXT_RECEIVERS_COUNT.toFlags(contextReceiverParametersCount)
+
+    override val modality get() = AbiModality.FINAL // No need to render modality for constructors.
+    override val isConstructor get() = true
+    override val isInline get() = IS_INLINE.get(flags)
+    override val isSuspend get() = false
+    override val hasExtensionReceiverParameter get() = false
+    override val contextReceiverParametersCount get() = CONTEXT_RECEIVERS_COUNT.get(flags)
+    override val returnType get() = null // No need to render return type for constructors.
+    override val typeParameters get() = emptyList<AbiTypeParameter>()
+    override fun hasAnnotation(annotationClassName: AbiQualifiedName) = annotationClassName in annotations
+
+    companion object {
+        private val IS_INLINE = FlagField.booleanFirst()
+        private val CONTEXT_RECEIVERS_COUNT = FlagFieldEx.intAfter(IS_INLINE, BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiFunctionImpl(
+    override val qualifiedName: AbiQualifiedName,
+    override val signatures: AbiSignatures,
+    private val annotations: Set<AbiQualifiedName>,
+    modality: AbiModality,
+    isInline: Boolean,
+    isSuspend: Boolean,
+    override val typeParameters: List<AbiTypeParameter>,
+    hasExtensionReceiverParameter: Boolean,
+    contextReceiverParametersCount: Int,
+    override val valueParameters: List<AbiValueParameter>,
+    override val returnType: AbiType?
+) : AbiFunction {
+    private val flags = IS_INLINE.toFlags(isInline) or
+            IS_SUSPEND.toFlags(isSuspend) or
+            HAS_EXTENSION_RECEIVER.toFlags(hasExtensionReceiverParameter) or
+            CONTEXT_RECEIVERS_COUNT.toFlags(contextReceiverParametersCount) or
+            MODALITY.toFlags(modality)
+
+    override val modality get() = MODALITY.get(flags)
+    override val isConstructor get() = false
+    override val isInline get() = IS_INLINE.get(flags)
+    override val isSuspend get() = IS_SUSPEND.get(flags)
+    override val hasExtensionReceiverParameter get() = HAS_EXTENSION_RECEIVER.get(flags)
+    override val contextReceiverParametersCount get() = CONTEXT_RECEIVERS_COUNT.get(flags)
+    override fun hasAnnotation(annotationClassName: AbiQualifiedName) = annotationClassName in annotations
+
+    companion object {
+        /** JVM allows max 255 parameters for a function. Storing such number requires just 8 bits. */
+        const val BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT = 8
+
+        private val IS_INLINE = FlagField.booleanFirst()
+        private val IS_SUSPEND = FlagField.booleanAfter(IS_INLINE)
+        private val HAS_EXTENSION_RECEIVER = FlagField.booleanAfter(IS_SUSPEND)
+        private val CONTEXT_RECEIVERS_COUNT = FlagFieldEx.intAfter(HAS_EXTENSION_RECEIVER, BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT)
+        private val MODALITY = FlagFieldEx.after<AbiModality>(CONTEXT_RECEIVERS_COUNT)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiValueParameterImpl(
+    override val type: AbiType,
+    isVararg: Boolean,
+    hasDefaultArg: Boolean,
+    isNoinline: Boolean,
+    isCrossinline: Boolean
+) : AbiValueParameter {
+    private val flags = IS_VARARG.toFlags(isVararg) or
+            HAS_DEFAULT_ARG.toFlags(hasDefaultArg) or
+            IS_NOINLINE.toFlags(isNoinline) or
+            IS_CROSSINLINE.toFlags(isCrossinline)
+
+    override val isVararg get() = IS_VARARG.get(flags)
+    override val hasDefaultArg get() = HAS_DEFAULT_ARG.get(flags)
+    override val isNoinline get() = IS_NOINLINE.get(flags)
+    override val isCrossinline get() = IS_CROSSINLINE.get(flags)
+
+    companion object {
+        private val IS_VARARG = FlagField.booleanFirst()
+        private val HAS_DEFAULT_ARG = FlagField.booleanAfter(IS_VARARG)
+        private val IS_NOINLINE = FlagField.booleanAfter(HAS_DEFAULT_ARG)
+        private val IS_CROSSINLINE = FlagField.booleanAfter(IS_NOINLINE)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiPropertyImpl(
+    override val qualifiedName: AbiQualifiedName,
+    override val signatures: AbiSignatures,
+    private val annotations: Set<AbiQualifiedName>,
+    modality: AbiModality,
+    kind: AbiPropertyKind,
+    override val getter: AbiFunction?,
+    override val setter: AbiFunction?
+) : AbiProperty {
+    private val flags = MODALITY.toFlags(modality) or PROPERTY_KIND.toFlags(kind)
+
+    override val modality get() = MODALITY.get(flags)
+    override val kind get() = PROPERTY_KIND.get(flags)
+    override fun hasAnnotation(annotationClassName: AbiQualifiedName) = annotationClassName in annotations
+
+    companion object {
+        private val MODALITY = FlagFieldEx.first<AbiModality>()
+        private val PROPERTY_KIND = FlagFieldEx.after<AbiPropertyKind>(MODALITY)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal class AbiTypeParameterImpl(
+    override val tag: String,
+    variance: AbiVariance,
+    isReified: Boolean,
+    override val upperBounds: List<AbiType>
+) : AbiTypeParameter {
+    private val flags = IS_REIFIED.toFlags(isReified) or VARIANCE.toFlags(variance)
+
+    override val variance = VARIANCE.get(flags)
+    override val isReified = IS_REIFIED.get(flags)
+
+    companion object {
+        private val IS_REIFIED = FlagField.booleanFirst()
+        private val VARIANCE = FlagFieldEx.after<AbiVariance>(IS_REIFIED)
+    }
+}
+
+@ExperimentalLibraryAbiReader
+internal object DynamicTypeImpl : AbiType.Dynamic
+
+@ExperimentalLibraryAbiReader
+internal object ErrorTypeImpl : AbiType.Error
+
+@ExperimentalLibraryAbiReader
+internal class SimpleTypeImpl(
+    override val classifierReference: AbiClassifierReference,
+    override val arguments: List<AbiTypeArgument>,
+    override val nullability: AbiTypeNullability
+) : AbiType.Simple
+
+@ExperimentalLibraryAbiReader
+internal object StarProjectionImpl : AbiTypeArgument.StarProjection
+
+@ExperimentalLibraryAbiReader
+internal class TypeProjectionImpl(
+    override val type: AbiType,
+    override val variance: AbiVariance
+) : AbiTypeArgument.TypeProjection
+
+@ExperimentalLibraryAbiReader
+internal class ClassReferenceImpl(override val className: AbiQualifiedName) : AbiClassifierReference.ClassReference
+
+@ExperimentalLibraryAbiReader
+internal class TypeParameterReferenceImpl(override val tag: String) : AbiClassifierReference.TypeParameterReference

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/impl/LibraryAbiReaderImpl.kt

@@ -0,0 +1,728 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi.impl
+
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet
+import org.jetbrains.kotlin.backend.common.serialization.*
+import org.jetbrains.kotlin.backend.common.serialization.encodings.*
+import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolData.SymbolKind.CLASS_SYMBOL
+import org.jetbrains.kotlin.backend.common.serialization.encodings.BinarySymbolData.SymbolKind.TYPE_PARAMETER_SYMBOL
+import org.jetbrains.kotlin.descriptors.ClassKind
+import org.jetbrains.kotlin.descriptors.Modality
+import org.jetbrains.kotlin.ir.util.IdSignature
+import org.jetbrains.kotlin.ir.util.IdSignature.*
+import org.jetbrains.kotlin.ir.util.IdSignatureRenderer
+import org.jetbrains.kotlin.ir.util.render
+import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.library.abi.*
+import org.jetbrains.kotlin.library.abi.AbiClassifierReference.ClassReference
+import org.jetbrains.kotlin.library.abi.AbiTypeNullability.*
+import org.jetbrains.kotlin.metadata.ProtoBuf
+import org.jetbrains.kotlin.name.FqName
+import org.jetbrains.kotlin.name.SpecialNames
+import org.jetbrains.kotlin.types.Variance
+import org.jetbrains.kotlin.utils.*
+import org.jetbrains.kotlin.utils.addToStdlib.ifTrue
+import java.io.File
+import org.jetbrains.kotlin.konan.file.File as KFile
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrClass as ProtoClass
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclaration as ProtoDeclaration
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrDeclarationBase as ProtoDeclarationBase
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrEnumEntry as ProtoEnumEntry
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrFile as ProtoFile
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrFunctionBase as ProtoFunctionBase
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrProperty as ProtoProperty
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrValueParameter as ProtoValueParameter
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrConstructorCall as ProtoConstructorCall
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrType as ProtoType
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrDefinitelyNotNullType as ProtoIrDefinitelyNotNullType
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleType as ProtoSimpleType
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleTypeNullability as ProtoSimpleTypeNullability
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrSimpleTypeLegacy as ProtoSimpleTypeLegacy
+import org.jetbrains.kotlin.backend.common.serialization.proto.IrTypeParameter as ProtoTypeParameter
+import org.jetbrains.kotlin.backend.common.serialization.IrFlags as ProtoFlags
+
+@ExperimentalLibraryAbiReader
+internal class LibraryAbiReaderImpl(libraryFile: File, filters: List<AbiReadingFilter>) {
+    private val library = resolveSingleFileKlib(
+        KFile(libraryFile.absolutePath),
+        strategy = ToolingSingleFileKlibResolveStrategy
+    )
+
+    private val compositeFilter: AbiReadingFilter.Composite? = if (filters.isNotEmpty()) AbiReadingFilter.Composite(filters) else null
+
+    fun readAbi(): LibraryAbi {
+        val supportedSignatureVersions = readSupportedSignatureVersions()
+
+        return LibraryAbi(
+            manifest = readManifest(),
+            uniqueName = library.uniqueName,
+            signatureVersions = supportedSignatureVersions,
+            topLevelDeclarations = LibraryDeserializer(library, supportedSignatureVersions, compositeFilter).deserialize()
+        )
+    }
+
+    private fun readManifest(): LibraryManifest {
+        val versions = library.versions
+        return LibraryManifest(
+            platform = library.builtInsPlatform,
+            nativeTargets = library.nativeTargets.sorted(),
+            compilerVersion = versions.compilerVersion,
+            abiVersion = versions.abiVersion?.toString(),
+            libraryVersion = versions.libraryVersion,
+            irProviderName = library.irProviderName
+        )
+    }
+
+    private fun readSupportedSignatureVersions(): Set<AbiSignatureVersion> {
+        return library.versions.irSignatureVersions.mapTo(hashSetOf()) { AbiSignatureVersions.resolveByVersionNumber(it.number) }
+    }
+}
+
+@ExperimentalLibraryAbiReader
+private class LibraryDeserializer(
+    private val library: KotlinLibrary,
+    supportedSignatureVersions: Set<AbiSignatureVersion>,
+    private val compositeFilter: AbiReadingFilter.Composite?
+) {
+    private val interner = IrInterningService()
+
+    private val annotationsInterner = object {
+        private val uniqueAnnotationClassNames = ObjectOpenHashSet<AbiQualifiedName>()
+        fun intern(annotationClassName: AbiQualifiedName): AbiQualifiedName = uniqueAnnotationClassNames.addOrGet(annotationClassName)
+    }
+
+    private val needV1Signatures = AbiSignatureVersions.Supported.V1 in supportedSignatureVersions
+    private val needV2Signatures = AbiSignatureVersions.Supported.V2 in supportedSignatureVersions
+
+    private fun <T : AbiDeclaration> T?.discardIfExcluded(): T? =
+        if (this != null && compositeFilter?.isDeclarationExcluded(this) == true) null else this
+
+    private inner class FileDeserializer(fileIndex: Int) {
+        private val fileReader = IrLibraryFileFromBytes(IrKlibBytesSource(library, fileIndex))
+
+        private val packageName: AbiCompoundName
+        private val topLevelDeclarationIds: List<Int>
+        private val signatureDeserializer: IdSignatureDeserializer
+        private val typeDeserializer: TypeDeserializer
+
+        init {
+            val proto = ProtoFile.parseFrom(library.file(fileIndex).codedInputStream, IrLibraryFileFromBytes.extensionRegistryLite)
+            topLevelDeclarationIds = proto.declarationIdList
+
+            val packageFQN = fileReader.deserializeFqName(proto.fqNameList)
+            packageName = AbiCompoundName(packageFQN)
+
+            val fileSignature = FileSignature(
+                id = Any(), // Just an unique object.
+                fqName = FqName(packageFQN),
+                fileName = if (proto.hasFileEntry() && proto.fileEntry.hasName()) proto.fileEntry.name else "<unknown>"
+            )
+            signatureDeserializer = IdSignatureDeserializer(fileReader, fileSignature, interner)
+            typeDeserializer = TypeDeserializer(fileReader, signatureDeserializer)
+        }
+
+        fun deserializeTo(output: MutableList<AbiDeclaration>) {
+            if (compositeFilter?.isPackageExcluded(packageName) == true)
+                return
+
+            topLevelDeclarationIds.mapNotNullTo(output) { topLevelDeclarationId ->
+                deserializeDeclaration(
+                    proto = fileReader.declaration(topLevelDeclarationId),
+                    containingEntity = ContainingEntity.Package(packageName),
+                    parentTypeParameterResolver = null
+                )
+            }
+        }
+
+        private fun deserializeDeclaration(
+            proto: ProtoDeclaration,
+            containingEntity: ContainingEntity,
+            parentTypeParameterResolver: TypeParameterResolver?
+        ): AbiDeclaration? =
+            when (proto.declaratorCase) {
+                ProtoDeclaration.DeclaratorCase.IR_CLASS -> deserializeClass(proto.irClass, containingEntity, parentTypeParameterResolver)
+                ProtoDeclaration.DeclaratorCase.IR_CONSTRUCTOR -> deserializeFunction(
+                    proto.irConstructor.base,
+                    isConstructor = true,
+                    containingEntity,
+                    parentTypeParameterResolver
+                )
+                ProtoDeclaration.DeclaratorCase.IR_FUNCTION -> deserializeFunction(
+                    proto.irFunction.base,
+                    isConstructor = false,
+                    containingEntity,
+                    parentTypeParameterResolver
+                )
+                ProtoDeclaration.DeclaratorCase.IR_PROPERTY -> deserializeProperty(
+                    proto.irProperty,
+                    containingEntity,
+                    parentTypeParameterResolver
+                )
+                ProtoDeclaration.DeclaratorCase.IR_ENUM_ENTRY -> deserializeEnumEntry(proto.irEnumEntry, containingEntity)
+                else -> null
+            }.discardIfExcluded()
+
+        private fun deserializeClass(
+            proto: ProtoClass,
+            containingEntity: ContainingEntity,
+            parentTypeParameterResolver: TypeParameterResolver?,
+        ): AbiClass? {
+            val annotations = deserializeAnnotations(proto.base)
+            val containingClassModality = (containingEntity as? ContainingEntity.Class)?.modality
+
+            if (!computeVisibilityStatus(proto.base, annotations, containingClassModality).isPubliclyVisible)
+                return null
+
+            val flags = ClassFlags.decode(proto.base.flags)
+
+            val modality = flags.modality.toAbiModality(
+                containingClassModality = null // Open nested classes in a final class remain open.
+            )
+
+            val qualifiedName = deserializeQualifiedName(proto.name, containingEntity)
+            val thisClassEntity = ContainingEntity.Class(qualifiedName, modality)
+
+            // Note: For inner classes pass the `parentTypeParameterResolver` to the constructor so that it could be
+            // possible to resolve TPs by delegating to the parent TP resolver. For non-inner classes just keep
+            // "level" to facilitate the proper TP numbering.
+            val thisClassTypeParameterResolver = TypeParameterResolver(
+                declarationName = qualifiedName,
+                parent = if (flags.isInner) parentTypeParameterResolver else null,
+                levelAdjustment = if (!flags.isInner && parentTypeParameterResolver != null) parentTypeParameterResolver.level + 1 else 0
+            )
+
+            val memberDeclarations = proto.declarationList.memoryOptimizedMapNotNull { declaration ->
+                deserializeDeclaration(declaration, containingEntity = thisClassEntity, thisClassTypeParameterResolver)
+            }
+
+            return AbiClassImpl(
+                qualifiedName = qualifiedName,
+                signatures = deserializeSignatures(proto.base),
+                annotations = annotations,
+                modality = modality,
+                kind = when (val kind = flags.kind) {
+                    ClassKind.CLASS -> AbiClassKind.CLASS
+                    ClassKind.INTERFACE -> AbiClassKind.INTERFACE
+                    ClassKind.OBJECT -> AbiClassKind.OBJECT
+                    ClassKind.ENUM_CLASS -> AbiClassKind.ENUM_CLASS
+                    ClassKind.ANNOTATION_CLASS -> AbiClassKind.ANNOTATION_CLASS
+                    ClassKind.ENUM_ENTRY -> error("Unexpected class kind: $kind")
+                },
+                isInner = flags.isInner,
+                isValue = flags.isValue,
+                isFunction = flags.isFun,
+                superTypes = deserializeTypes(proto.superTypeList, thisClassTypeParameterResolver) { type ->
+                    !isKotlinBuiltInType(type, KOTLIN_ANY_QUALIFIED_NAME, DEFINITELY_NOT_NULL) && typeDeserializer.isPubliclyVisible(type)
+                },
+                declarations = memberDeclarations,
+                typeParameters = deserializeTypeParameters(proto.typeParameterList, thisClassTypeParameterResolver)
+            )
+        }
+
+        private inline fun deserializeTypes(
+            typeIds: List<Int>,
+            typeParameterResolver: TypeParameterResolver,
+            predicate: (AbiType) -> Boolean
+        ): List<AbiType> = typeIds.memoryOptimizedMapNotNull { typeId ->
+            typeDeserializer.deserializeType(typeId, typeParameterResolver).takeIf(predicate)
+        }
+
+        private fun deserializeEnumEntry(proto: ProtoEnumEntry, containingEntity: ContainingEntity): AbiEnumEntry {
+            return AbiEnumEntryImpl(
+                qualifiedName = deserializeQualifiedName(proto.name, containingEntity),
+                signatures = deserializeSignatures(proto.base),
+                annotations = deserializeAnnotations(proto.base)
+            )
+        }
+
+        private fun deserializeFunction(
+            proto: ProtoFunctionBase,
+            isConstructor: Boolean,
+            containingEntity: ContainingEntity,
+            parentTypeParameterResolver: TypeParameterResolver?
+        ): AbiFunction? {
+            val annotations = deserializeAnnotations(proto.base)
+
+            val containingClassModality = when (containingEntity) {
+                is ContainingEntity.Class -> containingEntity.modality
+                is ContainingEntity.Property -> containingEntity.containingClassModality
+                else -> null
+            }
+
+            val parentPropertyVisibilityStatus = (containingEntity as? ContainingEntity.Property)?.propertyVisibilityStatus
+            if (!computeVisibilityStatus(
+                    proto.base,
+                    annotations,
+                    containingClassModality,
+                    parentPropertyVisibilityStatus
+                ).isPubliclyVisible
+            ) {
+                return null
+            }
+
+            val flags = FunctionFlags.decode(proto.base.flags)
+            if (flags.isFakeOverride) // TODO: FO of class with supertype from interop library
+                return null
+
+            val nameAndType = BinaryNameAndType.decode(proto.nameType)
+            val functionName = deserializeQualifiedName(
+                nameId = nameAndType.nameIndex,
+                containingEntity = containingEntity
+            )
+
+            val thisFunctionTypeParameterResolver = when {
+                isConstructor -> {
+                    // Reuse the TP resolved from the class, as constructors can't have own TPs.
+                    parentTypeParameterResolver!!
+                }
+                containingEntity is ContainingEntity.Property -> {
+                    // 1. A TP of a serialized property accessor has signature that points to the property itself.
+                    //    So for the need of TP resolution it's necessary to pass the name of the property to the TP resolver.
+                    // 2. Properties don't have their own TPs, but their accessors can have TPs. This means that there is
+                    //    no need to create a TP resolver for a property, only for the accessor. To make rendering of
+                    //    accessor's TPs consistent with the position of the accessor inside the declaration's tree,
+                    //    it's necessary to adjust the "level" field inside the TP resolver by 1.
+                    TypeParameterResolver(containingEntity.propertyName, parentTypeParameterResolver, levelAdjustment = 1)
+                }
+                else -> TypeParameterResolver(functionName, parentTypeParameterResolver)
+            }
+
+            val extensionReceiver = if (proto.hasExtensionReceiver())
+                deserializeValueParameter(proto.extensionReceiver, thisFunctionTypeParameterResolver)
+            else
+                null
+            val contextReceiversCount = if (proto.hasContextReceiverParametersCount()) proto.contextReceiverParametersCount else 0
+
+            val allValueParameters = ArrayList<AbiValueParameter>()
+            allValueParameters.addIfNotNull(extensionReceiver)
+            proto.valueParameterList.mapTo(allValueParameters) { deserializeValueParameter(it, thisFunctionTypeParameterResolver) }
+
+            return if (isConstructor) {
+                check(extensionReceiver == null) { "Unexpected extension receiver found for constructor $functionName" }
+
+                AbiConstructorImpl(
+                    qualifiedName = functionName,
+                    signatures = deserializeSignatures(proto.base),
+                    annotations = annotations,
+                    isInline = flags.isInline,
+                    contextReceiverParametersCount = contextReceiversCount,
+                    valueParameters = allValueParameters.compact()
+                )
+            } else {
+                // Show only a non-trivial return type for the others.
+                val nonTrivialReturnType = typeDeserializer.deserializeType(nameAndType.typeIndex, thisFunctionTypeParameterResolver)
+                    .takeUnless { isKotlinBuiltInType(it, KOTLIN_UNIT_QUALIFIED_NAME, DEFINITELY_NOT_NULL) }
+
+                AbiFunctionImpl(
+                    qualifiedName = functionName,
+                    signatures = deserializeSignatures(proto.base),
+                    annotations = annotations,
+                    modality = flags.modality.toAbiModality(containingClassModality),
+                    isInline = flags.isInline,
+                    isSuspend = flags.isSuspend,
+                    typeParameters = deserializeTypeParameters(proto.typeParameterList, thisFunctionTypeParameterResolver),
+                    hasExtensionReceiverParameter = extensionReceiver != null,
+                    contextReceiverParametersCount = contextReceiversCount,
+                    valueParameters = allValueParameters.compact(),
+                    returnType = nonTrivialReturnType
+                )
+            }
+        }
+
+        private fun deserializeProperty(
+            proto: ProtoProperty,
+            containingEntity: ContainingEntity,
+            typeParameterResolver: TypeParameterResolver?
+        ): AbiProperty? {
+            val annotations = deserializeAnnotations(proto.base)
+            val containingClassModality = (containingEntity as? ContainingEntity.Class)?.modality
+
+            val visibilityStatus = computeVisibilityStatus(proto.base, annotations, containingClassModality)
+            if (!visibilityStatus.isPubliclyVisible)
+                return null
+
+            val flags = PropertyFlags.decode(proto.base.flags)
+            if (flags.isFakeOverride) // TODO: FO of class with supertype from interop library
+                return null
+
+            val qualifiedName = deserializeQualifiedName(proto.name, containingEntity)
+            val thisPropertyEntity = ContainingEntity.Property(qualifiedName, containingClassModality, visibilityStatus)
+
+            return AbiPropertyImpl(
+                qualifiedName = qualifiedName,
+                signatures = deserializeSignatures(proto.base),
+                annotations = annotations,
+                modality = flags.modality.toAbiModality(containingClassModality),
+                kind = when {
+                    flags.isConst -> AbiPropertyKind.CONST_VAL
+                    flags.isVar -> AbiPropertyKind.VAR
+                    else -> AbiPropertyKind.VAL
+                },
+                getter = proto.hasGetter().ifTrue {
+                    deserializeFunction(
+                        proto = proto.getter.base,
+                        isConstructor = false,
+                        containingEntity = thisPropertyEntity,
+                        parentTypeParameterResolver = typeParameterResolver
+                    ).discardIfExcluded()
+                },
+                setter = proto.hasSetter().ifTrue {
+                    deserializeFunction(
+                        proto = proto.setter.base,
+                        isConstructor = false,
+                        containingEntity = thisPropertyEntity,
+                        parentTypeParameterResolver = typeParameterResolver
+                    ).discardIfExcluded()
+                }
+            )
+        }
+
+        private fun deserializeQualifiedName(nameId: Int, containingEntity: ContainingEntity): AbiQualifiedName {
+            return containingEntity.computeNestedName(fileReader.string(nameId))
+        }
+
+        private fun deserializeSignatures(proto: ProtoDeclarationBase): AbiSignatures {
+            val signature = deserializeIdSignature(proto.symbol)
+
+            return AbiSignaturesImpl(
+                signatureV1 = if (needV1Signatures) signature.render(IdSignatureRenderer.LEGACY) else null,
+                signatureV2 = if (needV2Signatures) signature.render(IdSignatureRenderer.DEFAULT) else null
+            )
+        }
+
+        private fun deserializeTypeParameters(
+            protos: List<ProtoTypeParameter>,
+            typeParameterResolver: TypeParameterResolver,
+        ): List<AbiTypeParameter> = protos.memoryOptimizedMapIndexed { index, proto ->
+            val flags = TypeParameterFlags.decode(proto.base.flags)
+
+            AbiTypeParameterImpl(
+                tag = typeParameterResolver.computeTypeParameterTag(index),
+                variance = flags.variance.toAbiVariance(),
+                isReified = flags.isReified,
+                upperBounds = deserializeTypes(proto.superTypeList, typeParameterResolver) { type ->
+                    !isKotlinBuiltInType(type, KOTLIN_ANY_QUALIFIED_NAME, MARKED_NULLABLE)
+                }
+            )
+        }
+
+        private fun deserializeAnnotations(proto: ProtoDeclarationBase): Set<AbiQualifiedName> {
+            fun deserialize(annotation: ProtoConstructorCall): AbiQualifiedName {
+                val signature = deserializeIdSignature(annotation.symbol)
+                val annotationClassName = when {
+                    signature is CommonSignature -> signature
+                    signature is CompositeSignature && signature.container is FileSignature -> signature.inner as CommonSignature
+                    else -> error("Unexpected annotation signature encountered: ${signature::class.java}, ${signature.render()}")
+                }.extractQualifiedName { rawRelativeName ->
+                    check(rawRelativeName.endsWith(INIT_SUFFIX)) {
+                        "Annotation constructor name does not have '$INIT_SUFFIX' suffix: $rawRelativeName"
+                    }
+                    rawRelativeName.substring(0, rawRelativeName.length - INIT_SUFFIX.length)
+                }
+
+                // Avoid duplicated instances of popular signature names:
+                return annotationsInterner.intern(annotationClassName)
+            }
+
+            return when (proto.annotationCount) {
+                0 -> return emptySet()
+                1 -> return setOf(deserialize(proto.annotationList[0]))
+                else -> proto.annotationList.mapTo(SmartSet.create(), ::deserialize)
+            }
+        }
+
+        private fun computeVisibilityStatus(
+            proto: ProtoDeclarationBase,
+            annotations: Set<AbiQualifiedName>,
+            containingClassModality: AbiModality?,
+            parentPropertyVisibilityStatus: VisibilityStatus? = null
+        ): VisibilityStatus = when (ProtoFlags.VISIBILITY.get(proto.flags.toInt())) {
+            ProtoBuf.Visibility.PUBLIC -> VisibilityStatus.PUBLIC
+
+            ProtoBuf.Visibility.PROTECTED -> {
+                if (containingClassModality == AbiModality.FINAL)
+                    VisibilityStatus.NON_PUBLIC
+                else
+                    VisibilityStatus.PUBLIC
+            }
+
+            ProtoBuf.Visibility.INTERNAL -> when {
+                parentPropertyVisibilityStatus == VisibilityStatus.INTERNAL_PUBLISHED_API -> VisibilityStatus.INTERNAL_PUBLISHED_API
+                PUBLISHED_API_CONSTRUCTOR_QUALIFIED_NAME in annotations -> VisibilityStatus.INTERNAL_PUBLISHED_API
+                else -> VisibilityStatus.NON_PUBLIC
+            }
+
+            else -> VisibilityStatus.NON_PUBLIC
+        }
+
+        private fun deserializeIdSignature(symbolId: Long): IdSignature {
+            val signatureId = BinarySymbolData.decode(symbolId).signatureId
+            return signatureDeserializer.deserializeIdSignature(signatureId)
+        }
+
+        private fun deserializeValueParameter(
+            proto: ProtoValueParameter,
+            typeParameterResolver: TypeParameterResolver
+        ): AbiValueParameter {
+            val flags = ValueParameterFlags.decode(proto.base.flags)
+
+            return AbiValueParameterImpl(
+                type = typeDeserializer.deserializeType(BinaryNameAndType.decode(proto.nameType).typeIndex, typeParameterResolver),
+                isVararg = proto.hasVarargElementType(),
+                hasDefaultArg = proto.hasDefaultValue(),
+                isNoinline = flags.isNoInline,
+                isCrossinline = flags.isCrossInline
+            )
+        }
+    }
+
+    private sealed interface ContainingEntity {
+        fun computeNestedName(simpleName: String): AbiQualifiedName
+
+        class Package(val packageName: AbiCompoundName) : ContainingEntity {
+            override fun computeNestedName(simpleName: String) = qualifiedName(packageName, simpleName)
+        }
+
+        class Class(val className: AbiQualifiedName, val modality: AbiModality) : ContainingEntity {
+            override fun computeNestedName(simpleName: String) = qualifiedName(className, simpleName)
+        }
+
+        class Property(
+            val propertyName: AbiQualifiedName,
+            val containingClassModality: AbiModality?,
+            val propertyVisibilityStatus: VisibilityStatus
+        ) : ContainingEntity {
+            override fun computeNestedName(simpleName: String) = qualifiedName(propertyName, simpleName)
+        }
+
+        companion object {
+            private fun qualifiedName(packageName: AbiCompoundName, topLevelSimpleName: String) =
+                AbiQualifiedName(packageName, AbiCompoundName(topLevelSimpleName))
+
+            private fun qualifiedName(parentName: AbiQualifiedName, memberSimpleName: String) =
+                AbiQualifiedName(
+                    parentName.packageName,
+                    AbiCompoundName("${parentName.relativeName}${AbiCompoundName.SEPARATOR}$memberSimpleName")
+                )
+        }
+    }
+
+    private class TypeParameterResolver(
+        private val declarationName: AbiQualifiedName,
+        val parent: TypeParameterResolver?,
+        levelAdjustment: Int = 0
+    ) {
+        val level: Int = (parent?.let { it.level + 1 } ?: 0) + levelAdjustment
+
+        fun computeTypeParameterTag(index: Int): String {
+            val tagPrefix = computeTagPrefix(index)
+            return if (level > 0) "$tagPrefix$level" else tagPrefix
+        }
+
+        fun resolveTypeParameterTag(declarationName: AbiQualifiedName, index: Int): String {
+            return if (declarationName == this.declarationName)
+                computeTypeParameterTag(index)
+            else
+                parent?.resolveTypeParameterTag(declarationName, index)
+                    ?: error("Type parameter with local index $index can not be resolved for $declarationName")
+        }
+
+        companion object {
+            private const val ALPHABET_SIZE: Int = 'Z' - 'A' + 1
+
+            private fun computeTagPrefix(index: Int): String {
+                val result = SmartList<Char>()
+
+                var quotient = index
+                var remainder = quotient % ALPHABET_SIZE
+                do {
+                    result += ('A' + remainder)
+                    quotient /= ALPHABET_SIZE
+                    remainder = (quotient - 1) % ALPHABET_SIZE
+                } while (quotient != 0)
+
+                return if (result.size == 1) result[0].toString() else result.asReversed().joinToString(separator = "")
+            }
+        }
+    }
+
+    private class TypeDeserializer(
+        private val libraryFile: IrLibraryFile,
+        private val signatureDeserializer: IdSignatureDeserializer
+    ) {
+        private val typeIdToTypeCache = HashMap<Int, AbiType>()
+        private val nonPublicTopLevelClassNames = HashSet<AbiQualifiedName>()
+
+        fun deserializeType(typeId: Int, typeParameterResolver: TypeParameterResolver): AbiType {
+            return typeIdToTypeCache.computeIfAbsent(typeId) {
+                val proto = libraryFile.type(typeId)
+                when (val kindCase = proto.kindCase) {
+                    ProtoType.KindCase.DNN -> deserializeDefinitelyNotNullType(proto.dnn, typeParameterResolver)
+                    ProtoType.KindCase.SIMPLE -> deserializeSimpleType(proto.simple, typeParameterResolver)
+                    ProtoType.KindCase.LEGACYSIMPLE -> deserializeSimpleType(proto.legacySimple, typeParameterResolver)
+                    ProtoType.KindCase.DYNAMIC -> DynamicTypeImpl
+                    ProtoType.KindCase.ERROR -> ErrorTypeImpl
+                    ProtoType.KindCase.KIND_NOT_SET -> error("Unexpected IR type: $kindCase")
+                }
+            }
+        }
+
+        fun isPubliclyVisible(type: AbiType): Boolean =
+            ((type as? AbiType.Simple)?.classifierReference as? ClassReference)?.className !in nonPublicTopLevelClassNames
+
+        private fun deserializeDefinitelyNotNullType(
+            proto: ProtoIrDefinitelyNotNullType,
+            typeParameterResolver: TypeParameterResolver,
+        ): AbiType {
+            assert(proto.typesCount == 1) { "Only DefinitelyNotNull type is now supported" }
+
+            val underlyingType = deserializeType(proto.getTypes(0), typeParameterResolver)
+            return if (underlyingType is AbiType.Simple && underlyingType.nullability != DEFINITELY_NOT_NULL)
+                SimpleTypeImpl(underlyingType.classifierReference, underlyingType.arguments, DEFINITELY_NOT_NULL)
+            else
+                underlyingType
+        }
+
+        private fun deserializeSimpleType(proto: ProtoSimpleType, typeParameterResolver: TypeParameterResolver): AbiType.Simple =
+            deserializeSimpleType(
+                symbolId = proto.classifier,
+                typeArgumentIds = proto.argumentList,
+                nullability = if (proto.hasNullability()) {
+                    when (proto.nullability!!) {
+                        ProtoSimpleTypeNullability.MARKED_NULLABLE -> MARKED_NULLABLE
+                        ProtoSimpleTypeNullability.NOT_SPECIFIED -> NOT_SPECIFIED
+                        ProtoSimpleTypeNullability.DEFINITELY_NOT_NULL -> DEFINITELY_NOT_NULL
+                    }
+                } else NOT_SPECIFIED,
+                typeParameterResolver
+            )
+
+        private fun deserializeSimpleType(proto: ProtoSimpleTypeLegacy, typeParameterResolver: TypeParameterResolver): AbiType.Simple =
+            deserializeSimpleType(
+                symbolId = proto.classifier,
+                typeArgumentIds = proto.argumentList,
+                nullability = if (proto.hasHasQuestionMark() && proto.hasQuestionMark) MARKED_NULLABLE else NOT_SPECIFIED,
+                typeParameterResolver
+            )
+
+        private fun deserializeSimpleType(
+            symbolId: Long,
+            typeArgumentIds: List<Long>,
+            nullability: AbiTypeNullability,
+            typeParameterResolver: TypeParameterResolver
+        ): AbiType.Simple {
+            val symbolData = BinarySymbolData.decode(symbolId)
+            val signature = signatureDeserializer.deserializeIdSignature(symbolData.signatureId)
+            val symbolKind = symbolData.kind
+
+            return when {
+                symbolKind == CLASS_SYMBOL && signature is CommonSignature -> {
+                    // Publicly visible class or interface.
+                    SimpleTypeImpl(
+                        classifierReference = ClassReferenceImpl(
+                            className = signature.extractQualifiedName()
+                        ),
+                        arguments = deserializeTypeArguments(typeArgumentIds, typeParameterResolver),
+                        nullability = nullability
+                    )
+                }
+
+                symbolKind == CLASS_SYMBOL && signature is CompositeSignature && signature.container is FileSignature -> {
+                    // Non-publicly visible classifier. Practically, this can only be a private top-level interface
+                    // that some publicly visible class inherits. Need to memoize it to avoid displaying it later among
+                    // supertypes of the inherited class.
+                    val className = (signature.inner as CommonSignature).extractQualifiedName()
+                    nonPublicTopLevelClassNames += className
+
+                    SimpleTypeImpl(
+                        classifierReference = ClassReferenceImpl(className),
+                        arguments = deserializeTypeArguments(typeArgumentIds, typeParameterResolver),
+                        nullability = nullability
+                    )
+                }
+
+                symbolKind == TYPE_PARAMETER_SYMBOL && signature is CompositeSignature -> {
+                    // A type-parameter.
+                    SimpleTypeImpl(
+                        classifierReference = TypeParameterReferenceImpl(
+                            tag = typeParameterResolver.resolveTypeParameterTag(
+                                declarationName = (signature.container as CommonSignature).extractQualifiedName(),
+                                index = (signature.inner as LocalSignature).index()
+                            )
+                        ),
+                        arguments = emptyList(),
+                        nullability = nullability
+                    )
+                }
+
+                else -> error("Unexpected combination of symbol kind ($symbolKind) and a signature: ${signature::class.java}, ${signature.render()}")
+            }
+        }
+
+        private fun deserializeTypeArguments(
+            typeArgumentIds: List<Long>,
+            typeParameterResolver: TypeParameterResolver
+        ): List<AbiTypeArgument> {
+            return if (typeArgumentIds.isEmpty())
+                emptyList()
+            else typeArgumentIds.memoryOptimizedMap { typeArgumentId ->
+                val typeProjection = BinaryTypeProjection.decode(typeArgumentId)
+                if (typeProjection.isStarProjection)
+                    StarProjectionImpl
+                else
+                    TypeProjectionImpl(
+                        type = deserializeType(typeProjection.typeIndex, typeParameterResolver),
+                        variance = typeProjection.variance.toAbiVariance()
+                    )
+            }
+        }
+    }
+
+    fun deserialize(): AbiTopLevelDeclarations {
+        val topLevels = ArrayList<AbiDeclaration>()
+
+        for (fileIndex in 0 until library.fileCount()) {
+            FileDeserializer(fileIndex).deserializeTo(topLevels)
+        }
+
+        return AbiTopLevelDeclarationsImpl(topLevels.compact())
+    }
+
+    private enum class VisibilityStatus(val isPubliclyVisible: Boolean) {
+        PUBLIC(true), INTERNAL_PUBLISHED_API(true), NON_PUBLIC(false)
+    }
+
+    companion object {
+        private val INIT_SUFFIX = "." + SpecialNames.INIT.asString()
+
+        private val KOTLIN_COMPOUND_NAME = AbiCompoundName("kotlin")
+        private val PUBLISHED_API_CONSTRUCTOR_QUALIFIED_NAME = AbiQualifiedName(KOTLIN_COMPOUND_NAME, AbiCompoundName("PublishedApi"))
+        private val KOTLIN_ANY_QUALIFIED_NAME = AbiQualifiedName(KOTLIN_COMPOUND_NAME, AbiCompoundName("Any"))
+        private val KOTLIN_UNIT_QUALIFIED_NAME = AbiQualifiedName(KOTLIN_COMPOUND_NAME, AbiCompoundName("Unit"))
+
+        private fun isKotlinBuiltInType(type: AbiType, className: AbiQualifiedName, nullability: AbiTypeNullability): Boolean {
+            if (type !is AbiType.Simple || type.nullability != nullability) return false
+            return (type.classifierReference as? ClassReference)?.className == className
+        }
+
+        private inline fun CommonSignature.extractQualifiedName(transformRelativeName: (String) -> String = { it }): AbiQualifiedName =
+            AbiQualifiedName(AbiCompoundName(packageFqName), AbiCompoundName(transformRelativeName(declarationFqName)))
+
+        private fun Modality.toAbiModality(containingClassModality: AbiModality?): AbiModality = when (this) {
+            Modality.FINAL -> AbiModality.FINAL
+            Modality.OPEN -> if (containingClassModality == AbiModality.FINAL) AbiModality.FINAL else AbiModality.OPEN
+            Modality.ABSTRACT -> AbiModality.ABSTRACT
+            Modality.SEALED -> AbiModality.SEALED
+        }
+
+        private fun Variance.toAbiVariance(): AbiVariance = when (this) {
+            Variance.INVARIANT -> AbiVariance.INVARIANT
+            Variance.IN_VARIANCE -> AbiVariance.IN
+            Variance.OUT_VARIANCE -> AbiVariance.OUT
+        }
+    }
+}

compiler/util-klib-abi/src/org/jetbrains/kotlin/library/abi/impl/LibraryAbiRendererImpl.kt

@@ -0,0 +1,434 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi.impl
+
+import org.jetbrains.kotlin.library.abi.*
+import org.jetbrains.kotlin.library.abi.impl.AbiFunctionImpl.Companion.BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT
+import org.jetbrains.kotlin.library.abi.impl.AbiRendererImpl.RenderedTopLevelDeclarations.printNestedDeclarationsInProperOrder as printTopLevelDeclarations
+import kotlin.text.Appendable
+
+@ExperimentalLibraryAbiReader
+internal class AbiRendererImpl(
+    private val libraryAbi: LibraryAbi,
+    private val settings: AbiRenderingSettings,
+    private val output: Appendable
+) {
+    fun render() {
+        printHeader()
+
+        if (settings.renderDeclarations)
+            printTopLevelDeclarations(libraryAbi.topLevelDeclarations, Printer(output, settings))
+    }
+
+    private fun printHeader() {
+        output.appendLine(
+            """
+                // Rendering settings:
+                // - Signature version: ${settings.renderedSignatureVersion.versionNumber}
+                // - Show manifest properties: ${settings.renderManifest}
+                // - Show declarations: ${settings.renderDeclarations}
+               
+                // Library unique name: <${libraryAbi.uniqueName}>
+            """.trimIndent()
+        )
+
+        if (settings.renderManifest) {
+            with(libraryAbi.manifest) {
+                listOfNotNull(
+                    platform?.let { "Platform" to it },
+                    nativeTargets.takeIf { it.isNotEmpty() }?.let { "Native targets" to it.joinToString(separator = ", ") },
+                    compilerVersion?.let { "Compiler version" to it },
+                    abiVersion?.let { "ABI version" to it },
+                    libraryVersion?.let { "Library version" to it },
+                    irProviderName?.let { "IR provider" to it }
+                ).forEach { (name, value) ->
+                    output.append("// ").append(name).append(": ").appendLine(value)
+                }
+            }
+        }
+    }
+
+    private class Printer(private val output: Appendable, private val settings: AbiRenderingSettings) {
+        private var indent = 0u
+
+        inline fun indented(block: () -> Unit) {
+            indent++
+            try {
+                block()
+            } finally {
+                indent--
+            }
+        }
+
+        fun printDeclaration(renderedDeclaration: RenderedDeclaration<*>, printOpeningBrace: Boolean = false): Unit = with(output) {
+            appendIndent()
+            append(renderedDeclaration.text)
+            if (printOpeningBrace) append(" {")
+            appendSignature(renderedDeclaration.declaration)
+            appendLine()
+        }
+
+        fun printClosingBrace(): Unit = with(output) {
+            appendIndent()
+            appendLine('}')
+        }
+
+        private fun appendIndent() {
+            for (i in 0u until indent) output.append(settings.indentationString)
+        }
+
+        private fun appendSignature(declaration: AbiDeclaration) {
+            output.append(" // ")
+            output.append(
+                declaration.signatures[settings.renderedSignatureVersion]
+                    ?: settings.whenSignatureNotFound(declaration, settings.renderedSignatureVersion)
+            )
+        }
+    }
+
+    private abstract class RenderedDeclarationContainerKind<T : AbiDeclarationContainer> {
+        /**
+         * Determines the relative order of the given [renderedDeclaration] to put it upper or lower in the renderer's output.
+         * The declarations of different kinds (ex: a class and a function) should always get a different order index.
+         */
+        protected abstract fun orderByDeclarationKind(renderedDeclaration: RenderedDeclaration<*>): Int
+
+        fun printNestedDeclarationsInProperOrder(container: T, printer: Printer) {
+            container.declarations.mapAndSort(
+                /**
+                 * Always sort declarations in a strictly specific order before printing them to make the output
+                 * be unaffected by the actual serialization order:
+                 *   1. by declaration kind, see [orderByDeclarationKind]
+                 *   2. by a fully-qualified name of the declaration
+                 *   3. by an additional ordering factor #1, see implementations of [RenderedDeclaration.additionalOrderingFactor1]
+                 *   4. by the text of the rendered declaration (excluding signatures!)
+                 *   5. by an additional ordering factor #2, see implementations of [RenderedDeclaration.additionalOrderingFactor2]
+                 */
+                compareBy(
+                    ::orderByDeclarationKind,
+                    { it.declaration.qualifiedName },
+                    RenderedDeclaration<*>::additionalOrderingFactor1,
+                    RenderedDeclaration<*>::text,
+                    RenderedDeclaration<*>::additionalOrderingFactor2
+                ),
+                RenderedDeclaration.Companion::createFor
+            ).forEach { it.print(printer) }
+        }
+    }
+
+    private object RenderedTopLevelDeclarations : RenderedDeclarationContainerKind<AbiTopLevelDeclarations>() {
+        /**
+         * When printing top-level declarations, the following order is used:
+         *   1. classes
+         *   2. properties
+         *   3. functions
+         */
+        override fun orderByDeclarationKind(renderedDeclaration: RenderedDeclaration<*>) =
+            when (renderedDeclaration.declaration) {
+                is AbiClass -> 1
+                is AbiProperty -> 2
+                is AbiFunction -> 3
+                else -> 4 // Normally, other types of declarations should not appear as top-level declarations.
+            }
+    }
+
+    private sealed class RenderedDeclaration<T : AbiDeclaration>(val declaration: T, val text: String) {
+        open val additionalOrderingFactor1: Int get() = 0
+        open val additionalOrderingFactor2: String get() = ""
+
+        abstract fun print(printer: Printer)
+
+        companion object {
+            fun createFor(declaration: AbiDeclaration): RenderedDeclaration<*> = when (declaration) {
+                is AbiFunction -> RenderedFunction(declaration)
+                is AbiProperty -> RenderedProperty(declaration)
+                is AbiClass -> RenderedClass(declaration)
+                is AbiEnumEntry -> RenderedEnumEntry(declaration)
+            }
+
+            fun StringBuilder.appendModalityOf(declaration: AbiDeclarationWithModality) {
+                append(declaration.modality.name.lowercase()).append(' ')
+            }
+
+            fun StringBuilder.appendNameOf(declaration: AbiDeclaration) {
+                // For non-top level declarations print only simple declaration's name.
+                val isTopLevel = declaration.qualifiedName.relativeName.nameSegmentsCount == 1
+                append(if (isTopLevel) declaration.qualifiedName else declaration.qualifiedName.relativeName.simpleName)
+            }
+
+            fun StringBuilder.appendTypeParametersOf(container: AbiTypeParametersContainer) {
+                if (container.typeParameters.isNotEmpty()) {
+                    container.typeParameters.joinTo(this, separator = ", ", prefix = "<", postfix = ">") { typeParameter ->
+                        appendTypeParameter(typeParameter)
+                    }
+                    append(' ')
+                }
+            }
+
+            private fun StringBuilder.appendTypeParameter(typeParameter: AbiTypeParameter): String {
+                append('#').append(typeParameter.tag).append(": ")
+                if (typeParameter.isReified) append("reified ")
+                appendVariance(typeParameter.variance)
+                when (typeParameter.upperBounds.size) {
+                    0 -> append("kotlin/Any?")
+                    1 -> appendType(typeParameter.upperBounds[0])
+                    else -> appendSortedTypes(typeParameter.upperBounds, separator = " & ", prefix = "", postfix = "")
+                }
+                return ""
+            }
+
+            fun StringBuilder.appendType(type: AbiType) {
+                when (type) {
+                    is AbiType.Simple -> when (val classifier = type.classifierReference) {
+                        is AbiClassifierReference.ClassReference -> {
+                            append(classifier.className)
+                            if (type.arguments.isNotEmpty()) {
+                                type.arguments.joinTo(this, separator = ", ", prefix = "<", postfix = ">") { typeArgument ->
+                                    appendTypeArgument(typeArgument)
+                                }
+                            }
+                            if (type.nullability == AbiTypeNullability.MARKED_NULLABLE) append('?')
+                        }
+                        is AbiClassifierReference.TypeParameterReference -> {
+                            append('#').append(classifier.tag)
+                            when (type.nullability) {
+                                AbiTypeNullability.MARKED_NULLABLE -> append('?')
+                                AbiTypeNullability.NOT_SPECIFIED -> Unit // Do nothing.
+                                AbiTypeNullability.DEFINITELY_NOT_NULL -> append("!!")
+                            }
+                        }
+                    }
+                    is AbiType.Dynamic -> append("dynamic")
+                    is AbiType.Error -> append("error")
+                }
+            }
+
+            private fun StringBuilder.appendTypeArgument(typeArgument: AbiTypeArgument): String {
+                when (typeArgument) {
+                    is AbiTypeArgument.StarProjection -> append('*')
+                    is AbiTypeArgument.TypeProjection -> {
+                        appendVariance(typeArgument.variance)
+                        appendType(typeArgument.type)
+                    }
+                }
+                return ""
+            }
+
+            private fun StringBuilder.appendVariance(variance: AbiVariance) {
+                when (variance) {
+                    AbiVariance.INVARIANT -> Unit
+                    AbiVariance.IN -> append("in ")
+                    AbiVariance.OUT -> append("out ")
+                }
+            }
+
+            fun StringBuilder.appendSortedTypes(types: List<AbiType>, separator: String, prefix: String, postfix: String) {
+                types.mapAndSort(naturalOrder()) { buildString { appendType(it) } }
+                    .joinTo(this, separator = separator, prefix = prefix, postfix = postfix)
+            }
+        }
+    }
+
+    private class RenderedClass(declaration: AbiClass) : RenderedDeclaration<AbiClass>(
+        declaration = declaration,
+        text = buildString {
+            appendModalityOf(declaration)
+            if (declaration.isInner) append("inner ")
+            if (declaration.isValue) append("value ")
+            if (declaration.isFunction) append("fun ")
+            appendClassKind(declaration.kind)
+
+            // Note: Type parameters are rendered before the class name, exactly as it is done for functions.
+            // This is done intentionally for the purpose of unification of the rendering notation for different
+            // types of declarations.
+            appendTypeParametersOf(declaration)
+            appendNameOf(declaration)
+            if (declaration.superTypes.isNotEmpty()) {
+                appendSortedTypes(declaration.superTypes, separator = ", ", prefix = " : ", postfix = "")
+            }
+        }
+    ) {
+        override fun print(printer: Printer) {
+            val hasChildren = declaration.declarations.isNotEmpty()
+            printer.printDeclaration(this, printOpeningBrace = hasChildren)
+            if (hasChildren) {
+                printer.indented {
+                    printNestedDeclarationsInProperOrder(container = declaration, printer)
+                }
+                printer.printClosingBrace()
+            }
+        }
+
+        companion object : RenderedDeclarationContainerKind<AbiClass>() {
+            private fun StringBuilder.appendClassKind(classKind: AbiClassKind) {
+                append(
+                    when (classKind) {
+                        AbiClassKind.CLASS -> "class"
+                        AbiClassKind.INTERFACE -> "interface"
+                        AbiClassKind.OBJECT -> "object"
+                        AbiClassKind.ENUM_CLASS -> "enum class"
+                        AbiClassKind.ANNOTATION_CLASS -> "annotation class"
+                    }
+                ).append(' ')
+            }
+
+            /**
+             * When printing nested declarations inside a class, the following order is used:
+             *   1. properties
+             *   2. constructors
+             *   3. functions
+             *   4. nested classes
+             *   5. enum entries
+             */
+            override fun orderByDeclarationKind(renderedDeclaration: RenderedDeclaration<*>) =
+                when (val declaration = renderedDeclaration.declaration) {
+                    is AbiProperty -> 1
+                    is AbiFunction -> if (declaration.isConstructor) 2 else 3
+                    is AbiClass -> 4
+                    is AbiEnumEntry -> 5
+                }
+        }
+    }
+
+    private class RenderedEnumEntry(declaration: AbiEnumEntry) : RenderedDeclaration<AbiEnumEntry>(
+        declaration = declaration,
+        text = buildString {
+            append("enum entry ")
+            appendNameOf(declaration)
+        }
+    ) {
+        override fun print(printer: Printer) = printer.printDeclaration(this)
+    }
+
+    private class RenderedProperty(declaration: AbiProperty) : RenderedDeclaration<AbiProperty>(
+        declaration = declaration,
+        text = buildString {
+            appendModalityOf(declaration)
+            appendPropertyKind(declaration.kind)
+            appendNameOf(declaration)
+        }
+    ) {
+        private val getter = declaration.getter?.let(::RenderedFunction)
+        private val setter = declaration.setter?.let(::RenderedFunction)
+
+        /** Delegates to [getter] or [setter], because the property itself knows nothing about value parameters. */
+        override val additionalOrderingFactor1 get() = (getter ?: setter)?.additionalOrderingFactor1 ?: 0
+
+        /**
+         * Use rendered text of [getter] or [setter], because the rendered text of the property does not include
+         * any value parameter information useful for the proper ordering among all properties that share
+         * the same qualified name (i.e. among overloaded properties).
+         */
+        override val additionalOrderingFactor2 get() = (getter ?: setter)?.text.orEmpty()
+
+        override fun print(printer: Printer) {
+            printer.printDeclaration(this)
+            printer.indented {
+                getter?.print(printer)
+                setter?.print(printer)
+            }
+        }
+
+        companion object {
+            private fun StringBuilder.appendPropertyKind(propertyKind: AbiPropertyKind) {
+                append(
+                    when (propertyKind) {
+                        AbiPropertyKind.VAL -> "val"
+                        AbiPropertyKind.CONST_VAL -> "const val"
+                        AbiPropertyKind.VAR -> "var"
+                    }
+                ).append(' ')
+            }
+        }
+    }
+
+    private class RenderedFunction(declaration: AbiFunction) : RenderedDeclaration<AbiFunction>(
+        declaration = declaration,
+        text = buildString {
+            if (!declaration.isConstructor || declaration.modality != AbiModality.FINAL) appendModalityOf(declaration)
+            if (declaration.isSuspend) append("suspend ")
+            if (declaration.isInline) append("inline ")
+            append(if (declaration.isConstructor) "constructor " else "fun ")
+            appendTypeParametersOf(declaration)
+            appendIrregularValueParametersOf(declaration)
+            appendNameOf(declaration)
+            appendRegularValueParametersOf(declaration)
+            appendReturnTypeOf(declaration)
+        }
+    ) {
+        /**
+         * Determines the relative order of a function to put it upper or lower in the renderer's output:
+         * - Functions without extension receiver go above functions with an extension receiver.
+         * - Functions without context receivers go above functions with context receivers.
+         * - The more regular value parameters function has, the lower it goes.
+         * - Same among functions with context receiver parameters.
+         */
+        override val additionalOrderingFactor1: Int
+            get() {
+                val extensionReceivers = if (declaration.hasExtensionReceiverParameter) 1 else 0
+                val contextReceivers = declaration.contextReceiverParametersCount
+                val regularParameters = declaration.valueParameters.size - extensionReceivers - contextReceivers
+                return (((contextReceivers shl 1) or extensionReceivers) shl BITS_ENOUGH_FOR_STORING_PARAMETERS_COUNT) or regularParameters
+            }
+
+        override fun print(printer: Printer) = printer.printDeclaration(this)
+
+        companion object {
+            private fun StringBuilder.appendIrregularValueParametersOf(function: AbiFunction) {
+                if (function.contextReceiverParametersCount > 0)
+                    function.valueParameters
+                        .asSequence()
+                        .apply { if (function.hasExtensionReceiverParameter) drop(1) }
+                        .take(function.contextReceiverParametersCount)
+                        .joinTo(this, separator = ", ", prefix = "context(", postfix = ") ") { valueParameter ->
+                            appendValueParameter(valueParameter)
+                        }
+
+                if (function.hasExtensionReceiverParameter) {
+                    append('(')
+                    appendValueParameter(function.valueParameters[0])
+                    append(").")
+                }
+            }
+
+            private fun StringBuilder.appendRegularValueParametersOf(function: AbiFunction) {
+                val skippedParametersCount = (if (function.hasExtensionReceiverParameter) 1 else 0) +
+                        function.contextReceiverParametersCount
+
+                function.valueParameters
+                    .asSequence()
+                    .drop(skippedParametersCount)
+                    .joinTo(this, separator = ", ", prefix = "(", postfix = ")") { valueParameter ->
+                        appendValueParameter(valueParameter)
+                    }
+            }
+
+            private fun StringBuilder.appendValueParameter(valueParameter: AbiValueParameter): String {
+                if (valueParameter.isNoinline) append("noinline ")
+                if (valueParameter.isCrossinline) append("crossinline ")
+                appendType(valueParameter.type)
+                if (valueParameter.isVararg) append("...")
+                if (valueParameter.hasDefaultArg) append(" =...")
+                return ""
+            }
+
+            private fun StringBuilder.appendReturnTypeOf(function: AbiFunction) {
+                function.returnType?.let { returnType -> append(": ").appendType(returnType) }
+            }
+        }
+    }
+
+    companion object {
+        private inline fun <T, R : Any> List<T>.mapAndSort(comparator: Comparator<R>, transform: (T) -> R): List<R> {
+            if (isEmpty()) return emptyList()
+
+            val result = ArrayList<R>(size)
+            mapTo(result, transform)
+            result.sortWith(comparator)
+            return result
+        }
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/AbiTypeArgumentRenderingTest.kt

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.abi.impl.*
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.EnumSource
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+class AbiTypeArgumentRenderingTest {
+    @ParameterizedTest
+    @EnumSource(AbiSignatureVersions.Supported::class)
+    internal fun test(signatureVersion: AbiSignatureVersions.Supported) {
+        val mockLibraryAbi = mockLibraryAbi(
+            signatureVersion,
+            mockClass(
+                name = "FinalClass",
+                mockType(
+                    "sample", "OpenClass",
+                    mockType("sample", "InvariantClass") to AbiVariance.INVARIANT,
+                    mockType("sample", "InClass") to AbiVariance.IN,
+                    mockType("sample", "OutClass") to AbiVariance.OUT,
+                    null
+                )
+            )
+        )
+
+        val renderedClass = LibraryAbiRenderer.render(mockLibraryAbi, AbiRenderingSettings(signatureVersion))
+            .lineSequence()
+            .filter(String::isNotBlank)
+            .last()
+
+        assertEquals(
+            "final class sample/FinalClass : sample/OpenClass<sample/InvariantClass, in sample/InClass, out sample/OutClass, *> // signature-v${signatureVersion.versionNumber}",
+            renderedClass
+        )
+    }
+
+    private fun mockLibraryAbi(signatureVersion: AbiSignatureVersion, vararg declarations: AbiDeclaration): LibraryAbi =
+        LibraryAbi(
+            manifest = LibraryManifest(null, emptyList(), null, null, null, null),
+            uniqueName = "type-argument-rendering-test",
+            signatureVersions = setOf(signatureVersion),
+            topLevelDeclarations = object : AbiTopLevelDeclarations {
+                override val declarations = declarations.toList()
+            }
+        )
+
+    private fun mockClass(name: String, vararg superTypes: AbiType): AbiClass =
+        AbiClassImpl(
+            qualifiedName = AbiQualifiedName(AbiCompoundName("sample"), AbiCompoundName(name)),
+            signatures = AbiSignaturesImpl("signature-v1", "signature-v2"),
+            annotations = emptySet(),
+            modality = AbiModality.FINAL,
+            kind = AbiClassKind.CLASS,
+            isInner = false,
+            isValue = false,
+            isFunction = false,
+            superTypes = superTypes.toList(),
+            declarations = emptyList(),
+            typeParameters = emptyList()
+        )
+
+    private fun mockType(packageName: String, className: String, vararg arguments: Pair<AbiType, AbiVariance>?): AbiType {
+        return SimpleTypeImpl(
+            classifierReference = ClassReferenceImpl(AbiQualifiedName(AbiCompoundName(packageName), AbiCompoundName(className))),
+            arguments = arguments.map { argument ->
+                if (argument == null)
+                    StarProjectionImpl
+                else
+                    TypeProjectionImpl(argument.first, argument.second)
+            },
+            nullability = AbiTypeNullability.NOT_SPECIFIED
+        )
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/AbstractLibraryAbiReaderTest.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.abi.impl.AbiSignatureVersions
+import org.jetbrains.kotlin.test.services.JUnit5Assertions.assertEqualsToFile
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.TestInfo
+import java.io.File
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+abstract class AbstractLibraryAbiReaderTest {
+    private lateinit var testName: String
+    private lateinit var buildDir: File
+
+    @BeforeEach
+    fun setUp(testInfo: TestInfo) {
+        testName = getTestName(testInfo)
+        buildDir = setUpBuildDir(testInfo)
+    }
+
+    fun runTest(relativePath: String) {
+        val (sourceFile, dumpFiles) = computeTestFiles(relativePath, AbiSignatureVersions.Supported.entries)
+
+        val filters = computeFiltersFromTestDirectives(sourceFile)
+
+        val library = buildLibrary(sourceFile, libraryName = testName, buildDir)
+        val libraryAbi = LibraryAbiReader.readAbiInfo(library, filters)
+
+        dumpFiles.entries.forEach { (signatureVersion, dumpFile) ->
+            val abiDump = LibraryAbiRenderer.render(
+                libraryAbi,
+                AbiRenderingSettings(signatureVersion)
+            )
+
+            assertEqualsToFile(dumpFile, abiDump)
+        }
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/AllKnownIrSignatureVersionsAreSupported.kt

@@ -0,0 +1,34 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.KotlinIrSignatureVersion
+import org.jetbrains.kotlin.library.abi.impl.AbiSignatureVersions
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.Test
+import java.util.*
+
+/**
+ * This test checks that all [KotlinIrSignatureVersion]s known to the current version of the compiler are supported
+ * by the same version of the ABI reader. The goal of the test is to make sure that a newly added [KotlinIrSignatureVersion]
+ * is not forgotten to be properly supported in the ABI reader.
+ *
+ * Note, that theoretically it is possible that the library itself is produced by a newer compiler, and thus it might
+ * have a newer [KotlinIrSignatureVersion] that is not yet supported by the current version of the ABI reader.
+ * This is a legal situation. And it is not covered by this test.
+ */
+@OptIn(ExperimentalLibraryAbiReader::class)
+class AllKnownIrSignatureVersionsAreSupported {
+    @Test
+    fun test() {
+        KotlinIrSignatureVersion.CURRENTLY_SUPPORTED_VERSIONS.forEach { irSignatureVersion ->
+            val abiSignatureVersion = AbiSignatureVersions.resolveByVersionNumber(irSignatureVersion.number)
+            assertTrue(abiSignatureVersion.isSupportedByAbiReader) {
+                "IR signature version $irSignatureVersion is not supported by the ABI reader"
+            }
+        }
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/GenerateLibraryAbiReaderTests.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.generators.generateTestGroupSuiteWithJUnit5
+
+fun main() {
+    System.setProperty("java.awt.headless", "true")
+
+    generateTestGroupSuiteWithJUnit5 {
+        testGroup("compiler/util-klib-abi/tests-gen", "compiler/util-klib-abi/testData") {
+            testClass<AbstractLibraryAbiReaderTest>(suiteTestClassName = "LibraryAbiReaderTest") {
+                model("content")
+            }
+        }
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/ManifestRenderingTest.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import org.jetbrains.kotlin.library.impl.BuiltInsPlatform
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Assertions.assertTrue
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInfo
+import java.io.File
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+class ManifestRenderingTest {
+    private lateinit var buildDir: File
+    private lateinit var sourceFile: File
+
+    @BeforeEach
+    fun setUp(testInfo: TestInfo) {
+        buildDir = setUpBuildDir(testInfo)
+        sourceFile = buildDir.resolve("source.kt").apply { createNewFile() } // Just an empty file.
+    }
+
+    @Test
+    fun renderWithManifest() {
+        val customManifest = LibraryManifest(
+            platform = BuiltInsPlatform.JS.name,
+            nativeTargets = listOf("ios_arm64", "ios_simulator_arm64", "macos_arm64", "macos_x64"),
+            compilerVersion = "1.23.45",
+            abiVersion = "2.34.56",
+            libraryVersion = "3.45.67",
+            irProviderName = "test_ir_provider_123"
+        )
+
+        val libraryFile = buildLibrary(sourceFile, libraryName = "sample-library", buildDir)
+        patchManifest(libraryFile, customManifest)
+
+        val readManifest = LibraryAbiReader.readAbiInfo(libraryFile).manifest
+        assertTrue(customManifest !== readManifest)
+        assertEquals(customManifest, readManifest)
+    }
+}

compiler/util-klib-abi/test/org/jetbrains/kotlin/library/abi/utils.kt

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi
+
+import com.intellij.openapi.vfs.StandardFileSystems
+import com.intellij.openapi.vfs.VirtualFileManager
+import com.intellij.openapi.vfs.local.CoreLocalFileSystem
+import com.intellij.psi.PsiManager
+import com.intellij.psi.SingleRootFileViewProvider
+import org.jetbrains.kotlin.cli.common.messages.MessageRenderer
+import org.jetbrains.kotlin.cli.common.messages.PrintingMessageCollector
+import org.jetbrains.kotlin.cli.js.klib.compileModuleToAnalyzedFirWithPsi
+import org.jetbrains.kotlin.cli.js.klib.serializeFirKlib
+import org.jetbrains.kotlin.cli.js.klib.transformFirToIr
+import org.jetbrains.kotlin.cli.jvm.compiler.EnvironmentConfigFiles
+import org.jetbrains.kotlin.cli.jvm.compiler.KotlinCoreEnvironment.Companion.createForParallelTests
+import org.jetbrains.kotlin.config.CommonConfigurationKeys
+import org.jetbrains.kotlin.config.CompilerConfiguration
+import org.jetbrains.kotlin.diagnostics.DiagnosticReporterFactory
+import org.jetbrains.kotlin.ir.backend.js.MainModule
+import org.jetbrains.kotlin.ir.backend.js.ModulesStructure
+import org.jetbrains.kotlin.js.config.JSConfigurationKeys
+import org.jetbrains.kotlin.konan.file.ZipFileSystemCacheableAccessor
+import org.jetbrains.kotlin.konan.file.unzipTo
+import org.jetbrains.kotlin.konan.file.zipDirAs
+import org.jetbrains.kotlin.konan.properties.saveToFile
+import org.jetbrains.kotlin.library.*
+import org.jetbrains.kotlin.psi.KtFile
+import org.jetbrains.kotlin.serialization.js.ModuleKind
+import org.jetbrains.kotlin.test.util.KtTestUtil.getHomeDirectory
+import org.jetbrains.kotlin.test.utils.TestDisposable
+import org.jetbrains.kotlin.util.parseSpaceSeparatedArgs
+import org.jetbrains.kotlin.utils.addToStdlib.ifNotEmpty
+import org.jetbrains.kotlin.utils.fileUtils.withReplacedExtensionOrNull
+import org.junit.jupiter.api.Assertions.*
+import org.junit.jupiter.api.TestInfo
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.PrintStream
+import java.nio.charset.Charset
+import org.jetbrains.kotlin.konan.file.File as KFile
+
+private val TestInfo.className: String get() = testClass.orElseGet { fail("Can't get test class name") }.simpleName
+private val TestInfo.methodName: String get() = testMethod.orElseGet { fail("Can't get test method name") }.name
+
+internal fun getTestName(testInfo: TestInfo): String = testInfo.methodName
+
+internal fun setUpBuildDir(testInfo: TestInfo): File {
+    val projectBuildDir = System.getenv(ENV_VAR_PROJECT_BUILD_DIR)
+        ?.let { File(it) }
+        ?: fail<Nothing>("$ENV_VAR_PROJECT_BUILD_DIR environment variable not specified")
+
+    assertTrue(projectBuildDir.isDirectory) { "Project build dir does not exist: $projectBuildDir" }
+
+    return projectBuildDir.resolve("t").resolve("${testInfo.className}.${testInfo.methodName}").apply {
+        deleteRecursively()
+        mkdirs()
+    }
+}
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+internal fun computeTestFiles(
+    relativePath: String,
+    signatureVersions: List<AbiSignatureVersion>
+): Pair<File, Map<AbiSignatureVersion, File>> {
+    assertTrue(signatureVersions.isNotEmpty()) { "Signature versions not specified" }
+
+    val sourceFile = File(getHomeDirectory()).resolve(relativePath)
+    assertEquals("kt", sourceFile.extension) { "Invalid source file: $sourceFile" }
+    assertTrue(sourceFile.isFile) { "Source file does not exist: $sourceFile" }
+
+    return sourceFile to signatureVersions.associateWith { signatureVersion ->
+        val dumpFile = sourceFile.withReplacedExtensionOrNull("kt", "v${signatureVersion.versionNumber}.txt")!!
+        assertTrue(dumpFile.isFile) { "Dump file does not exist: $dumpFile" }
+        dumpFile
+    }
+}
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+internal fun computeFiltersFromTestDirectives(sourceFile: File): List<AbiReadingFilter> {
+    fun String.parseQualifiedName() = AbiQualifiedName(
+        packageName = AbiCompoundName(substringBefore('/', missingDelimiterValue = "")),
+        relativeName = AbiCompoundName(substringAfter('/'))
+    )
+
+    val excludedPackages = mutableListOf<AbiCompoundName>()
+    val excludedClasses = mutableListOf<AbiQualifiedName>()
+    val nonPublicMarkers = mutableListOf<AbiQualifiedName>()
+
+    sourceFile.bufferedReader().lineSequence().forEach { line ->
+        if (!line.parseTestDirective(DIRECTIVE_EXCLUDED_PACKAGES, ::AbiCompoundName, excludedPackages::add)
+            && !line.parseTestDirective(DIRECTIVE_EXCLUDED_CLASSES, String::parseQualifiedName, excludedClasses::add)
+            && !line.parseTestDirective(DIRECTIVE_NON_PUBLIC_MARKERS, String::parseQualifiedName, nonPublicMarkers::add)
+        ) {
+            return listOfNotNull(
+                excludedPackages.ifNotEmpty(AbiReadingFilter::ExcludedPackages),
+                excludedClasses.ifNotEmpty(AbiReadingFilter::ExcludedClasses),
+                nonPublicMarkers.ifNotEmpty(AbiReadingFilter::NonPublicMarkerAnnotations)
+            )
+        }
+    }
+
+    return emptyList()
+}
+
+private inline fun <T> String.parseTestDirective(
+    directivePrefix: String,
+    parser: (String) -> T,
+    consumer: (T) -> Unit,
+): Boolean {
+    if (!startsWith(directivePrefix))
+        return false
+
+    val remainder = substring(directivePrefix.length)
+    try {
+        val items = parseSpaceSeparatedArgs(remainder)
+        items.forEach { item -> consumer(parser(item)) }
+        return true
+    } catch (e: Exception) {
+        throw fail<Nothing>("Failure during parsing test directive: $this", e)
+    }
+}
+
+private const val DIRECTIVE_EXCLUDED_PACKAGES = "// EXCLUDED_PACKAGES:"
+private const val DIRECTIVE_EXCLUDED_CLASSES = "// EXCLUDED_CLASSES:"
+private const val DIRECTIVE_NON_PUBLIC_MARKERS = "// NON_PUBLIC_MARKERS:"
+
+internal fun buildLibrary(sourceFile: File, libraryName: String, buildDir: File): File {
+    val configuration = CompilerConfiguration()
+    val environment = createForParallelTests(TestDisposable(), configuration, EnvironmentConfigFiles.JS_CONFIG_FILES)
+
+    configuration.put(CommonConfigurationKeys.MODULE_NAME, libraryName)
+    configuration.put(JSConfigurationKeys.MODULE_KIND, ModuleKind.PLAIN)
+    configuration.put(JSConfigurationKeys.PROPERTY_LAZY_INITIALIZATION, true)
+    configuration.put(JSConfigurationKeys.ZIP_FILE_SYSTEM_ACCESSOR, ZipFileSystemCacheableAccessor(2))
+
+    val psiManager = PsiManager.getInstance(environment.project)
+    val fileSystem = VirtualFileManager.getInstance().getFileSystem(StandardFileSystems.FILE_PROTOCOL) as CoreLocalFileSystem
+
+    val virtualFile = fileSystem.findFileByIoFile(sourceFile) ?: error("VirtualFile for $sourceFile not found")
+    val ktFiles = SingleRootFileViewProvider(psiManager, virtualFile).allFiles.filterIsInstance<KtFile>()
+
+    val diagnosticsReporter = DiagnosticReporterFactory.createPendingReporter()
+
+    val jsStdlib = File("libraries/stdlib/js-ir/build/classes/kotlin/js/main").absoluteFile
+    val dependencies = listOf(jsStdlib.absolutePath)
+
+    val moduleStructure = ModulesStructure(
+        project = environment.project,
+        mainModule = MainModule.SourceFiles(ktFiles),
+        compilerConfiguration = configuration,
+        dependencies = dependencies,
+        friendDependenciesPaths = emptyList()
+    )
+
+    val outputStream = ByteArrayOutputStream()
+    val messageCollector = PrintingMessageCollector(PrintStream(outputStream), MessageRenderer.PLAIN_FULL_PATHS, true)
+
+    val analyzedOutput = compileModuleToAnalyzedFirWithPsi(
+        moduleStructure = moduleStructure,
+        ktFiles = ktFiles,
+        libraries = dependencies,
+        friendLibraries = emptyList(),
+        diagnosticsReporter = diagnosticsReporter,
+        incrementalDataProvider = null,
+        lookupTracker = null,
+        useWasmPlatform = false
+    )
+
+    val fir2IrActualizedResult = transformFirToIr(moduleStructure, analyzedOutput.output, diagnosticsReporter)
+
+    if (analyzedOutput.reportCompilationErrors(moduleStructure, diagnosticsReporter, messageCollector)) {
+        val messages = outputStream.toByteArray().toString(Charset.forName("UTF-8"))
+        fail<Nothing>("The following errors occurred compiling test:\n$messages")
+    }
+
+    val libraryDir = KFile(buildDir.resolve(libraryName).absolutePath)
+    val libraryFile = KFile(libraryDir.absolutePath + ".klib")
+
+    serializeFirKlib(
+        moduleStructure = moduleStructure,
+        firOutputs = analyzedOutput.output,
+        fir2IrActualizedResult = fir2IrActualizedResult,
+        outputKlibPath = libraryDir.absolutePath,
+        messageCollector = messageCollector,
+        diagnosticsReporter = diagnosticsReporter,
+        jsOutputName = libraryName,
+        useWasmPlatform = false
+    )
+
+    if (messageCollector.hasErrors()) {
+        val messages = outputStream.toByteArray().toString(Charset.forName("UTF-8"))
+        fail<Nothing>("The following errors occurred serializing test klib:\n$messages")
+    }
+
+    libraryDir.zipDirAs(libraryFile)
+    libraryDir.deleteRecursively()
+
+    return File(libraryFile.absolutePath)
+}
+
+@OptIn(ExperimentalLibraryAbiReader::class)
+internal fun patchManifest(libraryFile: File, customManifest: LibraryManifest) {
+    val libraryKFile = KFile(libraryFile.absolutePath)
+    val manifestProperties = resolveSingleFileKlib(libraryKFile).manifestProperties
+
+    fun set(name: String, value: String?) {
+        assertTrue(!value.isNullOrBlank()) { "$name has invalid value: [$value]" }
+        manifestProperties[name] = value!!
+    }
+
+    set(KLIB_PROPERTY_BUILTINS_PLATFORM, customManifest.platform)
+    set(KLIB_PROPERTY_NATIVE_TARGETS, customManifest.nativeTargets.joinToString(" "))
+    set(KLIB_PROPERTY_COMPILER_VERSION, customManifest.compilerVersion)
+    set(KLIB_PROPERTY_ABI_VERSION, customManifest.abiVersion)
+    set(KLIB_PROPERTY_LIBRARY_VERSION, customManifest.libraryVersion)
+    set(KLIB_PROPERTY_IR_PROVIDER, customManifest.irProviderName)
+
+    assertEquals(libraryFile.extension, "klib")
+    val libraryDir = libraryFile.resolveSibling(libraryFile.nameWithoutExtension)
+    val libraryKDir = KFile(libraryDir.absolutePath)
+    libraryKFile.unzipTo(libraryKDir)
+    libraryKFile.deleteRecursively()
+
+    libraryDir.walkTopDown()
+        .filter { it.isFile && it.name == "manifest" }
+        .forEach { manifestProperties.saveToFile(KFile(it.absolutePath)) }
+
+    libraryKDir.zipDirAs(libraryKFile)
+}
+
+private const val ENV_VAR_PROJECT_BUILD_DIR = "PROJECT_BUILD_DIR"

compiler/util-klib-abi/testData/content/callables.kt

@@ -0,0 +1,149 @@
+package callables.test
+
+fun regularFun(): String = ""
+fun regularFun(p1: Number): String = ""
+fun regularFun(p1: Int): String = ""
+fun regularFun(p1: Int, p2: Long): String = ""
+fun regularFun(p1: Number, p2: Long): String = ""
+fun regularFun(p1: Int, p2: Number): String = ""
+fun regularFun(p1: Number, p2: Number): String = ""
+fun Int.regularFun(): String = ""
+fun Long.regularFun(): String = ""
+fun Number.regularFun(): String = ""
+
+context(Int) fun regularFun(): String = ""
+context(Int) fun regularFun(p1: Number): String = ""
+context(Int) fun regularFun(p1: Int): String = ""
+context(Int) fun regularFun(p1: Int, p2: Long): String = ""
+context(Int) fun regularFun(p1: Number, p2: Long): String = ""
+context(Int) fun regularFun(p1: Int, p2: Number): String = ""
+context(Int) fun regularFun(p1: Number, p2: Number): String = ""
+context(Int) fun Int.regularFun(): String = ""
+context(Int) fun Long.regularFun(): String = ""
+context(Int) fun Number.regularFun(): String = ""
+
+context(Int, Long) fun regularFun(): String = ""
+context(Int, Long) fun regularFun(p1: Number): String = ""
+context(Int, Long) fun regularFun(p1: Int): String = ""
+context(Int, Long) fun regularFun(p1: Int, p2: Long): String = ""
+context(Int, Long) fun regularFun(p1: Number, p2: Long): String = ""
+context(Int, Long) fun regularFun(p1: Int, p2: Number): String = ""
+context(Int, Long) fun regularFun(p1: Number, p2: Number): String = ""
+context(Int, Long) fun Int.regularFun(): String = ""
+context(Int, Long) fun Long.regularFun(): String = ""
+context(Int, Long) fun Number.regularFun(): String = ""
+
+class FunctionContainer {
+    fun regularFun(): String = ""
+    fun regularFun(p1: Number): String = ""
+    fun regularFun(p1: Int): String = ""
+    fun regularFun(p1: Int, p2: Long): String = ""
+    fun regularFun(p1: Number, p2: Long): String = ""
+    fun regularFun(p1: Int, p2: Number): String = ""
+    fun regularFun(p1: Number, p2: Number): String = ""
+    fun Int.regularFun(): String = ""
+    fun Long.regularFun(): String = ""
+    fun Number.regularFun(): String = ""
+
+    context(Int) fun regularFun(): String = ""
+    context(Int) fun regularFun(p1: Number): String = ""
+    context(Int) fun regularFun(p1: Int): String = ""
+    context(Int) fun regularFun(p1: Int, p2: Long): String = ""
+    context(Int) fun regularFun(p1: Number, p2: Long): String = ""
+    context(Int) fun regularFun(p1: Int, p2: Number): String = ""
+    context(Int) fun regularFun(p1: Number, p2: Number): String = ""
+    context(Int) fun Int.regularFun(): String = ""
+    context(Int) fun Long.regularFun(): String = ""
+    context(Int) fun Number.regularFun(): String = ""
+
+    context(Int, Long) fun regularFun(): String = ""
+    context(Int, Long) fun regularFun(p1: Number): String = ""
+    context(Int, Long) fun regularFun(p1: Int): String = ""
+    context(Int, Long) fun regularFun(p1: Int, p2: Long): String = ""
+    context(Int, Long) fun regularFun(p1: Number, p2: Long): String = ""
+    context(Int, Long) fun regularFun(p1: Int, p2: Number): String = ""
+    context(Int, Long) fun regularFun(p1: Number, p2: Number): String = ""
+    context(Int, Long) fun Int.regularFun(): String = ""
+    context(Int, Long) fun Long.regularFun(): String = ""
+    context(Int, Long) fun Number.regularFun(): String = ""
+}
+
+suspend fun suspendFun(value: Int, block: (Int) -> String): String = ""
+suspend fun suspendFun(value: Int, block: suspend (Int) -> String): String = ""
+
+inline fun inlineFun(block: (Int) -> String): String = ""
+inline fun inlineFun(block: (Long) -> String): String = ""
+inline fun inlineFun(block: (Number) -> String): String = ""
+
+fun varargFun(vararg a: Int): String = ""
+fun varargFun(a: Array<Int>): String = ""
+fun varargFun(a: Array<out Int>): String = ""
+fun varargFun(a: Array<in Int>): String = ""
+
+fun varargFun(vararg a: String): String = ""
+fun varargFun(a: Array<String>): String = ""
+fun varargFun(a: Array<out String>): String = ""
+fun varargFun(a: Array<in String>): String = ""
+
+fun typeParameterFun(a: String): String = ""
+fun <T> typeParameterFun(a: String): String = ""
+fun <T> typeParameterFun(a: T): String = ""
+fun <T : Any> typeParameterFun(a: T): String = ""
+fun <T : CharSequence> typeParameterFun(a: T): String = ""
+fun <T> typeParameterFun(a: T): String where T : CharSequence, T : Appendable = ""
+
+val regularVal: String get() = ""
+val Int.regularVal: String get() = ""
+val Long.regularVal: String get() = ""
+val Number.regularVal: String get() = ""
+
+var regularVar: String get() = ""
+    set(_) = Unit
+var Int.regularVar: String get() = ""
+    set(_) = Unit
+var Long.regularVar: String get() = ""
+    set(_) = Unit
+var Number.regularVar: String get() = ""
+    set(_) = Unit
+
+val typeParameterVal: String get() = ""
+val <T> T.typeParameterVal: String where T : CharSequence, T : Appendable get() = ""
+
+var typeParameterVar: String get() = ""
+    set(_) = Unit
+var <T> T.typeParameterVar: String where T : CharSequence, T : Appendable get() = ""
+    set(_) = Unit
+
+const val constProperty: String = ""
+
+inline val inlineVal: String get() = ""
+inline var inlineVar: String get() = ""
+    set(_) = Unit
+
+class PropertyContainer {
+    val regularVal: String get() = ""
+    val Int.regularVal: String get() = ""
+    val Long.regularVal: String get() = ""
+    val Number.regularVal: String get() = ""
+
+    var regularVar: String get() = ""
+        set(_) = Unit
+    var Int.regularVar: String get() = ""
+        set(_) = Unit
+    var Long.regularVar: String get() = ""
+        set(_) = Unit
+    var Number.regularVar: String get() = ""
+        set(_) = Unit
+
+    val typeParameterVal: String get() = ""
+    val <T> T.typeParameterVal: String where T : CharSequence, T : Appendable get() = ""
+
+    var typeParameterVar: String get() = ""
+        set(_) = Unit
+    var <T> T.typeParameterVar: String where T : CharSequence, T : Appendable get() = ""
+        set(_) = Unit
+
+    inline val inlineVal: String get() = ""
+    inline var inlineVar: String get() = ""
+        set(_) = Unit
+}

compiler/util-klib-abi/testData/content/callables.v1.txt

@@ -0,0 +1,163 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testCallables>
+final class callables.test/FunctionContainer { // callables.test/FunctionContainer|null[0]
+    constructor <init>() // callables.test/FunctionContainer.<init>|-5645683436151566731[0]
+    final fun regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-1607736902443358908[0]
+    final fun regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|2610511202482030950[0]
+    final fun regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-1444308164954439959[0]
+    final fun regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|1253865780311160876[0]
+    final fun regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-7094704380505542965[0]
+    final fun regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|-378948707834118549[0]
+    final fun regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-2271646920391707040[0]
+    final fun (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|2795910657932017532[0]
+    final fun (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-6283317282093795679[0]
+    final fun (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-2192609305655999008[0]
+    final fun context(kotlin/Int) regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-8267448815467806639[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|-111672199320661666[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-8697242820832893560[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|-5241394041073260245[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-5978317558626334421[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|291819780317361658[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|8928686497007243010[0]
+    final fun context(kotlin/Int) (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-5014308192639081145[0]
+    final fun context(kotlin/Long) (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-7399704652058443494[0]
+    final fun context(kotlin/Number) (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-2107005658606574142[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|2841212003589703997[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|-985389676546366868[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|1791390998424441841[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|2250042392910873061[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|1200032901543330229[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|-7756604040376043218[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|-5852923150600998663[0]
+    final fun context(kotlin/Int, kotlin/Int) (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-1047317519793480063[0]
+    final fun context(kotlin/Long, kotlin/Int) (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-4110111285900788090[0]
+    final fun context(kotlin/Number, kotlin/Int) (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|-3190887841330597637[0]
+}
+final class callables.test/PropertyContainer { // callables.test/PropertyContainer|null[0]
+    final val inlineVal // callables.test/PropertyContainer.inlineVal|-5201927927744237303[0]
+        final inline fun <get-inlineVal>(): kotlin/String // callables.test/PropertyContainer.inlineVal.<get-inlineVal>|-3774133809308892676[0]
+    final var inlineVar // callables.test/PropertyContainer.inlineVar|4093593025118739712[0]
+        final inline fun <get-inlineVar>(): kotlin/String // callables.test/PropertyContainer.inlineVar.<get-inlineVar>|5191851058645471995[0]
+        final inline fun <set-inlineVar>(kotlin/String) // callables.test/PropertyContainer.inlineVar.<set-inlineVar>|-1160421771960555320[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|8302928953435423801[0]
+        final fun <get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|-3202586928558914639[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|68831860860092280[0]
+        final fun (kotlin/Int).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|1142246892243086073[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|-5579099332440636214[0]
+        final fun (kotlin/Long).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|2341082381652662965[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|-5067332311376532792[0]
+        final fun (kotlin/Number).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|280416490180918505[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|6219482095538731779[0]
+        final fun <get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|-4669185078647138796[0]
+        final fun <set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|-4770127057965825178[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|4496565943717832687[0]
+        final fun (kotlin/Int).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|-6080445766330592605[0]
+        final fun (kotlin/Int).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|-3681323486923661283[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|1996981460395345177[0]
+        final fun (kotlin/Long).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|7034927826667428813[0]
+        final fun (kotlin/Long).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|1178143595556284736[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|-6923079879972526933[0]
+        final fun (kotlin/Number).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|2384277737300861982[0]
+        final fun (kotlin/Number).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|-6514051220363038309[0]
+    final val typeParameterVal // callables.test/PropertyContainer.typeParameterVal|4893664515247341696[0]
+        final fun <get-typeParameterVal>(): kotlin/String // callables.test/PropertyContainer.typeParameterVal.<get-typeParameterVal>|-166271421910940760[0]
+    final val typeParameterVal // callables.test/PropertyContainer.typeParameterVal|3916645226241752635[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<get-typeParameterVal>(): kotlin/String // callables.test/PropertyContainer.typeParameterVal.<get-typeParameterVal>|-3217792298032478048[0]
+    final var typeParameterVar // callables.test/PropertyContainer.typeParameterVar|6273344427230821135[0]
+        final fun <get-typeParameterVar>(): kotlin/String // callables.test/PropertyContainer.typeParameterVar.<get-typeParameterVar>|-3573990202711249503[0]
+        final fun <set-typeParameterVar>(kotlin/String) // callables.test/PropertyContainer.typeParameterVar.<set-typeParameterVar>|1653479554860734620[0]
+    final var typeParameterVar // callables.test/PropertyContainer.typeParameterVar|3838569829461573607[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<get-typeParameterVar>(): kotlin/String // callables.test/PropertyContainer.typeParameterVar.<get-typeParameterVar>|-2122591755051684684[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<set-typeParameterVar>(kotlin/String) // callables.test/PropertyContainer.typeParameterVar.<set-typeParameterVar>|-8363816135186264436[0]
+    constructor <init>() // callables.test/PropertyContainer.<init>|-5645683436151566731[0]
+}
+final const val callables.test/constProperty // callables.test/constProperty|-946595011727133850[0]
+    final fun <get-constProperty>(): kotlin/String // callables.test/constProperty.<get-constProperty>|4493949707887227090[0]
+final val callables.test/inlineVal // callables.test/inlineVal|-5201927927744237303[0]
+    final inline fun <get-inlineVal>(): kotlin/String // callables.test/inlineVal.<get-inlineVal>|-3774133809308892676[0]
+final var callables.test/inlineVar // callables.test/inlineVar|4093593025118739712[0]
+    final inline fun <get-inlineVar>(): kotlin/String // callables.test/inlineVar.<get-inlineVar>|5191851058645471995[0]
+    final inline fun <set-inlineVar>(kotlin/String) // callables.test/inlineVar.<set-inlineVar>|-1160421771960555320[0]
+final val callables.test/regularVal // callables.test/regularVal|8302928953435423801[0]
+    final fun <get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|-3202586928558914639[0]
+final val callables.test/regularVal // callables.test/regularVal|68831860860092280[0]
+    final fun (kotlin/Int).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|1142246892243086073[0]
+final val callables.test/regularVal // callables.test/regularVal|-5579099332440636214[0]
+    final fun (kotlin/Long).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|2341082381652662965[0]
+final val callables.test/regularVal // callables.test/regularVal|-5067332311376532792[0]
+    final fun (kotlin/Number).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|280416490180918505[0]
+final var callables.test/regularVar // callables.test/regularVar|6219482095538731779[0]
+    final fun <get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|-4669185078647138796[0]
+    final fun <set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|-4770127057965825178[0]
+final var callables.test/regularVar // callables.test/regularVar|4496565943717832687[0]
+    final fun (kotlin/Int).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|-6080445766330592605[0]
+    final fun (kotlin/Int).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|-3681323486923661283[0]
+final var callables.test/regularVar // callables.test/regularVar|1996981460395345177[0]
+    final fun (kotlin/Long).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|7034927826667428813[0]
+    final fun (kotlin/Long).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|1178143595556284736[0]
+final var callables.test/regularVar // callables.test/regularVar|-6923079879972526933[0]
+    final fun (kotlin/Number).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|2384277737300861982[0]
+    final fun (kotlin/Number).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|-6514051220363038309[0]
+final val callables.test/typeParameterVal // callables.test/typeParameterVal|4893664515247341696[0]
+    final fun <get-typeParameterVal>(): kotlin/String // callables.test/typeParameterVal.<get-typeParameterVal>|-166271421910940760[0]
+final val callables.test/typeParameterVal // callables.test/typeParameterVal|3916645226241752635[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<get-typeParameterVal>(): kotlin/String // callables.test/typeParameterVal.<get-typeParameterVal>|-3217792298032478048[0]
+final var callables.test/typeParameterVar // callables.test/typeParameterVar|6273344427230821135[0]
+    final fun <get-typeParameterVar>(): kotlin/String // callables.test/typeParameterVar.<get-typeParameterVar>|-3573990202711249503[0]
+    final fun <set-typeParameterVar>(kotlin/String) // callables.test/typeParameterVar.<set-typeParameterVar>|1653479554860734620[0]
+final var callables.test/typeParameterVar // callables.test/typeParameterVar|3838569829461573607[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<get-typeParameterVar>(): kotlin/String // callables.test/typeParameterVar.<get-typeParameterVar>|-2122591755051684684[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<set-typeParameterVar>(kotlin/String) // callables.test/typeParameterVar.<set-typeParameterVar>|-8363816135186264436[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/inlineFun|714409574025065146[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Long, kotlin/String>): kotlin/String // callables.test/inlineFun|-5246475948584640610[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Number, kotlin/String>): kotlin/String // callables.test/inlineFun|2898953589470570438[0]
+final fun callables.test/regularFun(): kotlin/String // callables.test/regularFun|-1607736902443358908[0]
+final fun callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|2610511202482030950[0]
+final fun callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|-1444308164954439959[0]
+final fun callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|1253865780311160876[0]
+final fun callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|-7094704380505542965[0]
+final fun callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|-378948707834118549[0]
+final fun callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|-2271646920391707040[0]
+final fun (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|2795910657932017532[0]
+final fun (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-6283317282093795679[0]
+final fun (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-2192609305655999008[0]
+final fun context(kotlin/Int) callables.test/regularFun(): kotlin/String // callables.test/regularFun|-8267448815467806639[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|-111672199320661666[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|-8697242820832893560[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|-5241394041073260245[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|-5978317558626334421[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|291819780317361658[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|8928686497007243010[0]
+final fun context(kotlin/Int) (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-5014308192639081145[0]
+final fun context(kotlin/Long) (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-7399704652058443494[0]
+final fun context(kotlin/Number) (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-2107005658606574142[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(): kotlin/String // callables.test/regularFun|2841212003589703997[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|-985389676546366868[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|1791390998424441841[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|2250042392910873061[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|1200032901543330229[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|-7756604040376043218[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|-5852923150600998663[0]
+final fun context(kotlin/Int, kotlin/Int) (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-1047317519793480063[0]
+final fun context(kotlin/Long, kotlin/Int) (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-4110111285900788090[0]
+final fun context(kotlin/Number, kotlin/Int) (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|-3190887841330597637[0]
+final suspend fun callables.test/suspendFun(kotlin/Int, kotlin.coroutines/SuspendFunction1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/suspendFun|-1581459052918133591[0]
+final suspend fun callables.test/suspendFun(kotlin/Int, kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/suspendFun|-3317053272398283488[0]
+final fun <#A: kotlin.text/Appendable & kotlin/CharSequence> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|-3186493094297971013[0]
+final fun <#A: kotlin/Any> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|8559938077715041629[0]
+final fun <#A: kotlin/Any?> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|1341548673669881771[0]
+final fun <#A: kotlin/Any?> callables.test/typeParameterFun(kotlin/String): kotlin/String // callables.test/typeParameterFun|-7424528499036142451[0]
+final fun <#A: kotlin/CharSequence> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|5015797153746384960[0]
+final fun callables.test/typeParameterFun(kotlin/String): kotlin/String // callables.test/typeParameterFun|-2809315713852528915[0]
+final fun callables.test/varargFun(kotlin/Array<in kotlin/Int>): kotlin/String // callables.test/varargFun|2576907898178423483[0]
+final fun callables.test/varargFun(kotlin/Array<in kotlin/String>): kotlin/String // callables.test/varargFun|-6880322114414235218[0]
+final fun callables.test/varargFun(kotlin/Array<kotlin/Int>): kotlin/String // callables.test/varargFun|7971016788147623730[0]
+final fun callables.test/varargFun(kotlin/Array<kotlin/String>): kotlin/String // callables.test/varargFun|4538895325734409312[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/Int>): kotlin/String // callables.test/varargFun|-2594127631335148538[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/String>): kotlin/String // callables.test/varargFun|-2225161879450919295[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/String>...): kotlin/String // callables.test/varargFun|4182110034727627686[0]
+final fun callables.test/varargFun(kotlin/IntArray...): kotlin/String // callables.test/varargFun|3145785856483302182[0]

compiler/util-klib-abi/testData/content/callables.v2.txt

@@ -0,0 +1,163 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testCallables>
+final class callables.test/FunctionContainer { // callables.test/FunctionContainer|null[0]
+    constructor <init>() // callables.test/FunctionContainer.<init>|<init>(){}[0]
+    final fun regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(){}[0]
+    final fun regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Int){}[0]
+    final fun regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Number){}[0]
+    final fun regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Int;kotlin.Long){}[0]
+    final fun regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Int;kotlin.Number){}[0]
+    final fun regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Number;kotlin.Long){}[0]
+    final fun regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun(kotlin.Number;kotlin.Number){}[0]
+    final fun (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun@kotlin.Int(){}[0]
+    final fun (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun@kotlin.Long(){}[0]
+    final fun (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun@kotlin.Number(){}[0]
+    final fun context(kotlin/Int) regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Int){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Number){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Int;kotlin.Long){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Int;kotlin.Number){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Number;kotlin.Long){}[0]
+    final fun context(kotlin/Int) regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int(kotlin.Number;kotlin.Number){}[0]
+    final fun context(kotlin/Int) (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int@kotlin.Int(){}[0]
+    final fun context(kotlin/Long) (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int@kotlin.Long(){}[0]
+    final fun context(kotlin/Number) (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int@kotlin.Number(){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int;kotlin.Long){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int;kotlin.Number){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number;kotlin.Long){}[0]
+    final fun context(kotlin/Int, kotlin/Long) regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number;kotlin.Number){}[0]
+    final fun context(kotlin/Int, kotlin/Int) (kotlin/Int).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Int(){}[0]
+    final fun context(kotlin/Long, kotlin/Int) (kotlin/Long).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Long(){}[0]
+    final fun context(kotlin/Number, kotlin/Int) (kotlin/Number).regularFun(): kotlin/String // callables.test/FunctionContainer.regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Number(){}[0]
+}
+final class callables.test/PropertyContainer { // callables.test/PropertyContainer|null[0]
+    final val inlineVal // callables.test/PropertyContainer.inlineVal|{}inlineVal[0]
+        final inline fun <get-inlineVal>(): kotlin/String // callables.test/PropertyContainer.inlineVal.<get-inlineVal>|<get-inlineVal>(){}[0]
+    final var inlineVar // callables.test/PropertyContainer.inlineVar|{}inlineVar[0]
+        final inline fun <get-inlineVar>(): kotlin/String // callables.test/PropertyContainer.inlineVar.<get-inlineVar>|<get-inlineVar>(){}[0]
+        final inline fun <set-inlineVar>(kotlin/String) // callables.test/PropertyContainer.inlineVar.<set-inlineVar>|<set-inlineVar>(kotlin.String){}[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|{}regularVal[0]
+        final fun <get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|<get-regularVal>(){}[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|@kotlin.Int{}regularVal[0]
+        final fun (kotlin/Int).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|<get-regularVal>@kotlin.Int(){}[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|@kotlin.Long{}regularVal[0]
+        final fun (kotlin/Long).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|<get-regularVal>@kotlin.Long(){}[0]
+    final val regularVal // callables.test/PropertyContainer.regularVal|@kotlin.Number{}regularVal[0]
+        final fun (kotlin/Number).<get-regularVal>(): kotlin/String // callables.test/PropertyContainer.regularVal.<get-regularVal>|<get-regularVal>@kotlin.Number(){}[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|{}regularVar[0]
+        final fun <get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|<get-regularVar>(){}[0]
+        final fun <set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|<set-regularVar>(kotlin.String){}[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|@kotlin.Int{}regularVar[0]
+        final fun (kotlin/Int).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|<get-regularVar>@kotlin.Int(){}[0]
+        final fun (kotlin/Int).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|<set-regularVar>@kotlin.Int(kotlin.String){}[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|@kotlin.Long{}regularVar[0]
+        final fun (kotlin/Long).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|<get-regularVar>@kotlin.Long(){}[0]
+        final fun (kotlin/Long).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|<set-regularVar>@kotlin.Long(kotlin.String){}[0]
+    final var regularVar // callables.test/PropertyContainer.regularVar|@kotlin.Number{}regularVar[0]
+        final fun (kotlin/Number).<get-regularVar>(): kotlin/String // callables.test/PropertyContainer.regularVar.<get-regularVar>|<get-regularVar>@kotlin.Number(){}[0]
+        final fun (kotlin/Number).<set-regularVar>(kotlin/String) // callables.test/PropertyContainer.regularVar.<set-regularVar>|<set-regularVar>@kotlin.Number(kotlin.String){}[0]
+    final val typeParameterVal // callables.test/PropertyContainer.typeParameterVal|{}typeParameterVal[0]
+        final fun <get-typeParameterVal>(): kotlin/String // callables.test/PropertyContainer.typeParameterVal.<get-typeParameterVal>|<get-typeParameterVal>(){}[0]
+    final val typeParameterVal // callables.test/PropertyContainer.typeParameterVal|@0:0{0§<kotlin.CharSequence&kotlin.text.Appendable>}typeParameterVal[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<get-typeParameterVal>(): kotlin/String // callables.test/PropertyContainer.typeParameterVal.<get-typeParameterVal>|<get-typeParameterVal>@0:0(){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+    final var typeParameterVar // callables.test/PropertyContainer.typeParameterVar|{}typeParameterVar[0]
+        final fun <get-typeParameterVar>(): kotlin/String // callables.test/PropertyContainer.typeParameterVar.<get-typeParameterVar>|<get-typeParameterVar>(){}[0]
+        final fun <set-typeParameterVar>(kotlin/String) // callables.test/PropertyContainer.typeParameterVar.<set-typeParameterVar>|<set-typeParameterVar>(kotlin.String){}[0]
+    final var typeParameterVar // callables.test/PropertyContainer.typeParameterVar|@0:0{0§<kotlin.CharSequence&kotlin.text.Appendable>}typeParameterVar[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<get-typeParameterVar>(): kotlin/String // callables.test/PropertyContainer.typeParameterVar.<get-typeParameterVar>|<get-typeParameterVar>@0:0(){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+        final fun <#A2: kotlin.text/Appendable & kotlin/CharSequence> (#A2).<set-typeParameterVar>(kotlin/String) // callables.test/PropertyContainer.typeParameterVar.<set-typeParameterVar>|<set-typeParameterVar>@0:0(kotlin.String){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+    constructor <init>() // callables.test/PropertyContainer.<init>|<init>(){}[0]
+}
+final const val callables.test/constProperty // callables.test/constProperty|{}constProperty[0]
+    final fun <get-constProperty>(): kotlin/String // callables.test/constProperty.<get-constProperty>|<get-constProperty>(){}[0]
+final val callables.test/inlineVal // callables.test/inlineVal|{}inlineVal[0]
+    final inline fun <get-inlineVal>(): kotlin/String // callables.test/inlineVal.<get-inlineVal>|<get-inlineVal>(){}[0]
+final var callables.test/inlineVar // callables.test/inlineVar|{}inlineVar[0]
+    final inline fun <get-inlineVar>(): kotlin/String // callables.test/inlineVar.<get-inlineVar>|<get-inlineVar>(){}[0]
+    final inline fun <set-inlineVar>(kotlin/String) // callables.test/inlineVar.<set-inlineVar>|<set-inlineVar>(kotlin.String){}[0]
+final val callables.test/regularVal // callables.test/regularVal|{}regularVal[0]
+    final fun <get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|<get-regularVal>(){}[0]
+final val callables.test/regularVal // callables.test/regularVal|@kotlin.Int{}regularVal[0]
+    final fun (kotlin/Int).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|<get-regularVal>@kotlin.Int(){}[0]
+final val callables.test/regularVal // callables.test/regularVal|@kotlin.Long{}regularVal[0]
+    final fun (kotlin/Long).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|<get-regularVal>@kotlin.Long(){}[0]
+final val callables.test/regularVal // callables.test/regularVal|@kotlin.Number{}regularVal[0]
+    final fun (kotlin/Number).<get-regularVal>(): kotlin/String // callables.test/regularVal.<get-regularVal>|<get-regularVal>@kotlin.Number(){}[0]
+final var callables.test/regularVar // callables.test/regularVar|{}regularVar[0]
+    final fun <get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|<get-regularVar>(){}[0]
+    final fun <set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|<set-regularVar>(kotlin.String){}[0]
+final var callables.test/regularVar // callables.test/regularVar|@kotlin.Int{}regularVar[0]
+    final fun (kotlin/Int).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|<get-regularVar>@kotlin.Int(){}[0]
+    final fun (kotlin/Int).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|<set-regularVar>@kotlin.Int(kotlin.String){}[0]
+final var callables.test/regularVar // callables.test/regularVar|@kotlin.Long{}regularVar[0]
+    final fun (kotlin/Long).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|<get-regularVar>@kotlin.Long(){}[0]
+    final fun (kotlin/Long).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|<set-regularVar>@kotlin.Long(kotlin.String){}[0]
+final var callables.test/regularVar // callables.test/regularVar|@kotlin.Number{}regularVar[0]
+    final fun (kotlin/Number).<get-regularVar>(): kotlin/String // callables.test/regularVar.<get-regularVar>|<get-regularVar>@kotlin.Number(){}[0]
+    final fun (kotlin/Number).<set-regularVar>(kotlin/String) // callables.test/regularVar.<set-regularVar>|<set-regularVar>@kotlin.Number(kotlin.String){}[0]
+final val callables.test/typeParameterVal // callables.test/typeParameterVal|{}typeParameterVal[0]
+    final fun <get-typeParameterVal>(): kotlin/String // callables.test/typeParameterVal.<get-typeParameterVal>|<get-typeParameterVal>(){}[0]
+final val callables.test/typeParameterVal // callables.test/typeParameterVal|@0:0{0§<kotlin.CharSequence&kotlin.text.Appendable>}typeParameterVal[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<get-typeParameterVal>(): kotlin/String // callables.test/typeParameterVal.<get-typeParameterVal>|<get-typeParameterVal>@0:0(){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+final var callables.test/typeParameterVar // callables.test/typeParameterVar|{}typeParameterVar[0]
+    final fun <get-typeParameterVar>(): kotlin/String // callables.test/typeParameterVar.<get-typeParameterVar>|<get-typeParameterVar>(){}[0]
+    final fun <set-typeParameterVar>(kotlin/String) // callables.test/typeParameterVar.<set-typeParameterVar>|<set-typeParameterVar>(kotlin.String){}[0]
+final var callables.test/typeParameterVar // callables.test/typeParameterVar|@0:0{0§<kotlin.CharSequence&kotlin.text.Appendable>}typeParameterVar[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<get-typeParameterVar>(): kotlin/String // callables.test/typeParameterVar.<get-typeParameterVar>|<get-typeParameterVar>@0:0(){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+    final fun <#A1: kotlin.text/Appendable & kotlin/CharSequence> (#A1).<set-typeParameterVar>(kotlin/String) // callables.test/typeParameterVar.<set-typeParameterVar>|<set-typeParameterVar>@0:0(kotlin.String){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/inlineFun|inlineFun(kotlin.Function1<kotlin.Int,kotlin.String>){}[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Long, kotlin/String>): kotlin/String // callables.test/inlineFun|inlineFun(kotlin.Function1<kotlin.Long,kotlin.String>){}[0]
+final inline fun callables.test/inlineFun(kotlin/Function1<kotlin/Number, kotlin/String>): kotlin/String // callables.test/inlineFun|inlineFun(kotlin.Function1<kotlin.Number,kotlin.String>){}[0]
+final fun callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun(){}[0]
+final fun callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|regularFun(kotlin.Int){}[0]
+final fun callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|regularFun(kotlin.Number){}[0]
+final fun callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun(kotlin.Int;kotlin.Long){}[0]
+final fun callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun(kotlin.Int;kotlin.Number){}[0]
+final fun callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun(kotlin.Number;kotlin.Long){}[0]
+final fun callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun(kotlin.Number;kotlin.Number){}[0]
+final fun (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun@kotlin.Int(){}[0]
+final fun (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun@kotlin.Long(){}[0]
+final fun (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun@kotlin.Number(){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Int){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Number){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Int;kotlin.Long){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Int;kotlin.Number){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Number;kotlin.Long){}[0]
+final fun context(kotlin/Int) callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int(kotlin.Number;kotlin.Number){}[0]
+final fun context(kotlin/Int) (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int@kotlin.Int(){}[0]
+final fun context(kotlin/Long) (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int@kotlin.Long(){}[0]
+final fun context(kotlin/Number) (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int@kotlin.Number(){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int;kotlin.Long){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Int, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Int;kotlin.Number){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number, kotlin/Long): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number;kotlin.Long){}[0]
+final fun context(kotlin/Int, kotlin/Long) callables.test/regularFun(kotlin/Number, kotlin/Number): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long(kotlin.Number;kotlin.Number){}[0]
+final fun context(kotlin/Int, kotlin/Int) (kotlin/Int).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Int(){}[0]
+final fun context(kotlin/Long, kotlin/Int) (kotlin/Long).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Long(){}[0]
+final fun context(kotlin/Number, kotlin/Int) (kotlin/Number).callables.test/regularFun(): kotlin/String // callables.test/regularFun|regularFun!kotlin.Int!kotlin.Long@kotlin.Number(){}[0]
+final suspend fun callables.test/suspendFun(kotlin/Int, kotlin.coroutines/SuspendFunction1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/suspendFun|suspendFun(kotlin.Int;kotlin.coroutines.SuspendFunction1<kotlin.Int,kotlin.String>){}[0]
+final suspend fun callables.test/suspendFun(kotlin/Int, kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // callables.test/suspendFun|suspendFun(kotlin.Int;kotlin.Function1<kotlin.Int,kotlin.String>){}[0]
+final fun <#A: kotlin.text/Appendable & kotlin/CharSequence> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|typeParameterFun(0:0){0§<kotlin.CharSequence&kotlin.text.Appendable>}[0]
+final fun <#A: kotlin/Any> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|typeParameterFun(0:0){0§<kotlin.Any>}[0]
+final fun <#A: kotlin/Any?> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|typeParameterFun(0:0){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/Any?> callables.test/typeParameterFun(kotlin/String): kotlin/String // callables.test/typeParameterFun|typeParameterFun(kotlin.String){0§<kotlin.Any?>}[0]
+final fun <#A: kotlin/CharSequence> callables.test/typeParameterFun(#A): kotlin/String // callables.test/typeParameterFun|typeParameterFun(0:0){0§<kotlin.CharSequence>}[0]
+final fun callables.test/typeParameterFun(kotlin/String): kotlin/String // callables.test/typeParameterFun|typeParameterFun(kotlin.String){}[0]
+final fun callables.test/varargFun(kotlin/Array<in kotlin/Int>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<in|kotlin.Int>){}[0]
+final fun callables.test/varargFun(kotlin/Array<in kotlin/String>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<in|kotlin.String>){}[0]
+final fun callables.test/varargFun(kotlin/Array<kotlin/Int>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<kotlin.Int>){}[0]
+final fun callables.test/varargFun(kotlin/Array<kotlin/String>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<kotlin.String>){}[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/Int>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<out|kotlin.Int>){}[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/String>): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<out|kotlin.String>){}[0]
+final fun callables.test/varargFun(kotlin/Array<out kotlin/String>...): kotlin/String // callables.test/varargFun|varargFun(kotlin.Array<out|kotlin.String>...){}[0]
+final fun callables.test/varargFun(kotlin/IntArray...): kotlin/String // callables.test/varargFun|varargFun(kotlin.IntArray...){}[0]

compiler/util-klib-abi/testData/content/classifiers.kt

@@ -0,0 +1,67 @@
+package classifiers.test
+
+class RegularClass(val property: String) {
+    fun function(): String = ""
+}
+
+annotation class AnnotationClass(val property: String) {
+    //fun function(): String = ""
+}
+
+value class ValueClass(val property: String) {
+    fun function(): String = ""
+}
+
+data class DataClass(val property: String) {
+    fun function(): String = ""
+}
+
+object Object {
+    val property: String = ""
+    fun function(): String = ""
+}
+
+interface Interface {
+    val property: String
+    fun function(): String
+}
+
+fun interface FunctionInterface {
+    //val property: String
+    fun function(): String
+}
+
+enum class EnumClassWithoutEntryClasses {
+    FOO_NO_CLASS, BAR_NO_CLASS, BAZ_NO_CLASS
+}
+
+enum class EnumClassWithEntryClasses {
+    FOO_HAS_CLASS { override fun function() = "" },
+    BAR_NO_CLASS,
+    BAZ_HAS_CLASS { override fun function() = "" };
+
+    open fun function(): String = ""
+}
+
+class CompanionHolder1 {
+    companion object // default name
+}
+class CompanionHolder2 {
+    companion object Companion // custom name
+}
+class CompanionHolder3 {
+    companion object DEFAULT // custom name
+}
+class CompanionHolder4 {
+    object Object // a regular nested object
+}
+
+class TopLevelClass {
+    class Nested {
+        class Nested
+        inner class Inner
+    }
+    inner class Inner {
+        inner class Inner
+    }
+}

compiler/util-klib-abi/testData/content/classifiers.v1.txt

@@ -0,0 +1,103 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testClassifiers>
+open annotation class classifiers.test/AnnotationClass : kotlin/Annotation { // classifiers.test/AnnotationClass|null[0]
+    final val property // classifiers.test/AnnotationClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/AnnotationClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // classifiers.test/AnnotationClass.<init>|1280618353163213788[0]
+}
+final class classifiers.test/CompanionHolder1 { // classifiers.test/CompanionHolder1|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder1.<init>|-5645683436151566731[0]
+    final object Companion // classifiers.test/CompanionHolder1.Companion|null[0]
+}
+final class classifiers.test/CompanionHolder2 { // classifiers.test/CompanionHolder2|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder2.<init>|-5645683436151566731[0]
+    final object Companion // classifiers.test/CompanionHolder2.Companion|null[0]
+}
+final class classifiers.test/CompanionHolder3 { // classifiers.test/CompanionHolder3|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder3.<init>|-5645683436151566731[0]
+    final object DEFAULT // classifiers.test/CompanionHolder3.DEFAULT|null[0]
+}
+final class classifiers.test/CompanionHolder4 { // classifiers.test/CompanionHolder4|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder4.<init>|-5645683436151566731[0]
+    final object Object // classifiers.test/CompanionHolder4.Object|null[0]
+}
+final class classifiers.test/DataClass { // classifiers.test/DataClass|null[0]
+    final val property // classifiers.test/DataClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/DataClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // classifiers.test/DataClass.<init>|1280618353163213788[0]
+    final fun component1(): kotlin/String // classifiers.test/DataClass.component1|162597135895221648[0]
+    final fun copy(kotlin/String =...): classifiers.test/DataClass // classifiers.test/DataClass.copy|-8298725480798151031[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // classifiers.test/DataClass.equals|4638265728071529943[0]
+    final fun function(): kotlin/String // classifiers.test/DataClass.function|-3322893411126713785[0]
+    final fun hashCode(): kotlin/Int // classifiers.test/DataClass.hashCode|3409210261493131192[0]
+    final fun toString(): kotlin/String // classifiers.test/DataClass.toString|-1522858123163872138[0]
+}
+open enum class classifiers.test/EnumClassWithEntryClasses : kotlin/Enum<classifiers.test/EnumClassWithEntryClasses> { // classifiers.test/EnumClassWithEntryClasses|null[0]
+    final val entries // classifiers.test/EnumClassWithEntryClasses.entries|-5134227801081826149[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<classifiers.test/EnumClassWithEntryClasses> // classifiers.test/EnumClassWithEntryClasses.entries.<get-entries>|-6068527377476727729[0]
+    open fun function(): kotlin/String // classifiers.test/EnumClassWithEntryClasses.function|-3322893411126713785[0]
+    final fun valueOf(kotlin/String): classifiers.test/EnumClassWithEntryClasses // classifiers.test/EnumClassWithEntryClasses.valueOf|-4683474617854611729[0]
+    final fun values(): kotlin/Array<classifiers.test/EnumClassWithEntryClasses> // classifiers.test/EnumClassWithEntryClasses.values|-8715569000920726747[0]
+    enum entry BAR_NO_CLASS // classifiers.test/EnumClassWithEntryClasses.BAR_NO_CLASS|null[0]
+    enum entry BAZ_HAS_CLASS // classifiers.test/EnumClassWithEntryClasses.BAZ_HAS_CLASS|null[0]
+    enum entry FOO_HAS_CLASS // classifiers.test/EnumClassWithEntryClasses.FOO_HAS_CLASS|null[0]
+}
+final enum class classifiers.test/EnumClassWithoutEntryClasses : kotlin/Enum<classifiers.test/EnumClassWithoutEntryClasses> { // classifiers.test/EnumClassWithoutEntryClasses|null[0]
+    final val entries // classifiers.test/EnumClassWithoutEntryClasses.entries|-5134227801081826149[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<classifiers.test/EnumClassWithoutEntryClasses> // classifiers.test/EnumClassWithoutEntryClasses.entries.<get-entries>|-6068527377476727729[0]
+    final fun valueOf(kotlin/String): classifiers.test/EnumClassWithoutEntryClasses // classifiers.test/EnumClassWithoutEntryClasses.valueOf|-4683474617854611729[0]
+    final fun values(): kotlin/Array<classifiers.test/EnumClassWithoutEntryClasses> // classifiers.test/EnumClassWithoutEntryClasses.values|-8715569000920726747[0]
+    enum entry BAR_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.BAR_NO_CLASS|null[0]
+    enum entry BAZ_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.BAZ_NO_CLASS|null[0]
+    enum entry FOO_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.FOO_NO_CLASS|null[0]
+}
+abstract fun interface classifiers.test/FunctionInterface { // classifiers.test/FunctionInterface|null[0]
+    abstract fun function(): kotlin/String // classifiers.test/FunctionInterface.function|-3322893411126713785[0]
+}
+abstract interface classifiers.test/Interface { // classifiers.test/Interface|null[0]
+    abstract val property // classifiers.test/Interface.property|4634558160746314112[0]
+        abstract fun <get-property>(): kotlin/String // classifiers.test/Interface.property.<get-property>|4838831487146901942[0]
+    abstract fun function(): kotlin/String // classifiers.test/Interface.function|-3322893411126713785[0]
+}
+final object classifiers.test/Object { // classifiers.test/Object|null[0]
+    final val property // classifiers.test/Object.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/Object.property.<get-property>|4838831487146901942[0]
+    final fun function(): kotlin/String // classifiers.test/Object.function|-3322893411126713785[0]
+}
+final class classifiers.test/RegularClass { // classifiers.test/RegularClass|null[0]
+    final val property // classifiers.test/RegularClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/RegularClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // classifiers.test/RegularClass.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // classifiers.test/RegularClass.function|-3322893411126713785[0]
+}
+final class classifiers.test/TopLevelClass { // classifiers.test/TopLevelClass|null[0]
+    constructor <init>() // classifiers.test/TopLevelClass.<init>|-5645683436151566731[0]
+    final inner class Inner { // classifiers.test/TopLevelClass.Inner|null[0]
+        constructor <init>() // classifiers.test/TopLevelClass.Inner.<init>|-5645683436151566731[0]
+        final inner class Inner { // classifiers.test/TopLevelClass.Inner.Inner|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Inner.Inner.<init>|-5645683436151566731[0]
+        }
+    }
+    final class Nested { // classifiers.test/TopLevelClass.Nested|null[0]
+        constructor <init>() // classifiers.test/TopLevelClass.Nested.<init>|-5645683436151566731[0]
+        final inner class Inner { // classifiers.test/TopLevelClass.Nested.Inner|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Nested.Inner.<init>|-5645683436151566731[0]
+        }
+        final class Nested { // classifiers.test/TopLevelClass.Nested.Nested|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final value class classifiers.test/ValueClass { // classifiers.test/ValueClass|null[0]
+    final val property // classifiers.test/ValueClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/ValueClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // classifiers.test/ValueClass.<init>|1280618353163213788[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // classifiers.test/ValueClass.equals|4638265728071529943[0]
+    final fun function(): kotlin/String // classifiers.test/ValueClass.function|-3322893411126713785[0]
+    final fun hashCode(): kotlin/Int // classifiers.test/ValueClass.hashCode|3409210261493131192[0]
+    final fun toString(): kotlin/String // classifiers.test/ValueClass.toString|-1522858123163872138[0]
+}

compiler/util-klib-abi/testData/content/classifiers.v2.txt

@@ -0,0 +1,103 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testClassifiers>
+open annotation class classifiers.test/AnnotationClass : kotlin/Annotation { // classifiers.test/AnnotationClass|null[0]
+    final val property // classifiers.test/AnnotationClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/AnnotationClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // classifiers.test/AnnotationClass.<init>|<init>(kotlin.String){}[0]
+}
+final class classifiers.test/CompanionHolder1 { // classifiers.test/CompanionHolder1|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder1.<init>|<init>(){}[0]
+    final object Companion // classifiers.test/CompanionHolder1.Companion|null[0]
+}
+final class classifiers.test/CompanionHolder2 { // classifiers.test/CompanionHolder2|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder2.<init>|<init>(){}[0]
+    final object Companion // classifiers.test/CompanionHolder2.Companion|null[0]
+}
+final class classifiers.test/CompanionHolder3 { // classifiers.test/CompanionHolder3|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder3.<init>|<init>(){}[0]
+    final object DEFAULT // classifiers.test/CompanionHolder3.DEFAULT|null[0]
+}
+final class classifiers.test/CompanionHolder4 { // classifiers.test/CompanionHolder4|null[0]
+    constructor <init>() // classifiers.test/CompanionHolder4.<init>|<init>(){}[0]
+    final object Object // classifiers.test/CompanionHolder4.Object|null[0]
+}
+final class classifiers.test/DataClass { // classifiers.test/DataClass|null[0]
+    final val property // classifiers.test/DataClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/DataClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // classifiers.test/DataClass.<init>|<init>(kotlin.String){}[0]
+    final fun component1(): kotlin/String // classifiers.test/DataClass.component1|component1(){}[0]
+    final fun copy(kotlin/String =...): classifiers.test/DataClass // classifiers.test/DataClass.copy|copy(kotlin.String){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // classifiers.test/DataClass.equals|equals(kotlin.Any?){}[0]
+    final fun function(): kotlin/String // classifiers.test/DataClass.function|function(){}[0]
+    final fun hashCode(): kotlin/Int // classifiers.test/DataClass.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // classifiers.test/DataClass.toString|toString(){}[0]
+}
+open enum class classifiers.test/EnumClassWithEntryClasses : kotlin/Enum<classifiers.test/EnumClassWithEntryClasses> { // classifiers.test/EnumClassWithEntryClasses|null[0]
+    final val entries // classifiers.test/EnumClassWithEntryClasses.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<classifiers.test/EnumClassWithEntryClasses> // classifiers.test/EnumClassWithEntryClasses.entries.<get-entries>|<get-entries>#static(){}[0]
+    open fun function(): kotlin/String // classifiers.test/EnumClassWithEntryClasses.function|function(){}[0]
+    final fun valueOf(kotlin/String): classifiers.test/EnumClassWithEntryClasses // classifiers.test/EnumClassWithEntryClasses.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<classifiers.test/EnumClassWithEntryClasses> // classifiers.test/EnumClassWithEntryClasses.values|values#static(){}[0]
+    enum entry BAR_NO_CLASS // classifiers.test/EnumClassWithEntryClasses.BAR_NO_CLASS|null[0]
+    enum entry BAZ_HAS_CLASS // classifiers.test/EnumClassWithEntryClasses.BAZ_HAS_CLASS|null[0]
+    enum entry FOO_HAS_CLASS // classifiers.test/EnumClassWithEntryClasses.FOO_HAS_CLASS|null[0]
+}
+final enum class classifiers.test/EnumClassWithoutEntryClasses : kotlin/Enum<classifiers.test/EnumClassWithoutEntryClasses> { // classifiers.test/EnumClassWithoutEntryClasses|null[0]
+    final val entries // classifiers.test/EnumClassWithoutEntryClasses.entries|#static{}entries[0]
+        final fun <get-entries>(): kotlin.enums/EnumEntries<classifiers.test/EnumClassWithoutEntryClasses> // classifiers.test/EnumClassWithoutEntryClasses.entries.<get-entries>|<get-entries>#static(){}[0]
+    final fun valueOf(kotlin/String): classifiers.test/EnumClassWithoutEntryClasses // classifiers.test/EnumClassWithoutEntryClasses.valueOf|valueOf#static(kotlin.String){}[0]
+    final fun values(): kotlin/Array<classifiers.test/EnumClassWithoutEntryClasses> // classifiers.test/EnumClassWithoutEntryClasses.values|values#static(){}[0]
+    enum entry BAR_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.BAR_NO_CLASS|null[0]
+    enum entry BAZ_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.BAZ_NO_CLASS|null[0]
+    enum entry FOO_NO_CLASS // classifiers.test/EnumClassWithoutEntryClasses.FOO_NO_CLASS|null[0]
+}
+abstract fun interface classifiers.test/FunctionInterface { // classifiers.test/FunctionInterface|null[0]
+    abstract fun function(): kotlin/String // classifiers.test/FunctionInterface.function|function(){}[0]
+}
+abstract interface classifiers.test/Interface { // classifiers.test/Interface|null[0]
+    abstract val property // classifiers.test/Interface.property|{}property[0]
+        abstract fun <get-property>(): kotlin/String // classifiers.test/Interface.property.<get-property>|<get-property>(){}[0]
+    abstract fun function(): kotlin/String // classifiers.test/Interface.function|function(){}[0]
+}
+final object classifiers.test/Object { // classifiers.test/Object|null[0]
+    final val property // classifiers.test/Object.property|{}property[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/Object.property.<get-property>|<get-property>(){}[0]
+    final fun function(): kotlin/String // classifiers.test/Object.function|function(){}[0]
+}
+final class classifiers.test/RegularClass { // classifiers.test/RegularClass|null[0]
+    final val property // classifiers.test/RegularClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/RegularClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // classifiers.test/RegularClass.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // classifiers.test/RegularClass.function|function(){}[0]
+}
+final class classifiers.test/TopLevelClass { // classifiers.test/TopLevelClass|null[0]
+    constructor <init>() // classifiers.test/TopLevelClass.<init>|<init>(){}[0]
+    final inner class Inner { // classifiers.test/TopLevelClass.Inner|null[0]
+        constructor <init>() // classifiers.test/TopLevelClass.Inner.<init>|<init>(){}[0]
+        final inner class Inner { // classifiers.test/TopLevelClass.Inner.Inner|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Inner.Inner.<init>|<init>(){}[0]
+        }
+    }
+    final class Nested { // classifiers.test/TopLevelClass.Nested|null[0]
+        constructor <init>() // classifiers.test/TopLevelClass.Nested.<init>|<init>(){}[0]
+        final inner class Inner { // classifiers.test/TopLevelClass.Nested.Inner|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Nested.Inner.<init>|<init>(){}[0]
+        }
+        final class Nested { // classifiers.test/TopLevelClass.Nested.Nested|null[0]
+            constructor <init>() // classifiers.test/TopLevelClass.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}
+final value class classifiers.test/ValueClass { // classifiers.test/ValueClass|null[0]
+    final val property // classifiers.test/ValueClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // classifiers.test/ValueClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // classifiers.test/ValueClass.<init>|<init>(kotlin.String){}[0]
+    final fun equals(kotlin/Any?): kotlin/Boolean // classifiers.test/ValueClass.equals|equals(kotlin.Any?){}[0]
+    final fun function(): kotlin/String // classifiers.test/ValueClass.function|function(){}[0]
+    final fun hashCode(): kotlin/Int // classifiers.test/ValueClass.hashCode|hashCode(){}[0]
+    final fun toString(): kotlin/String // classifiers.test/ValueClass.toString|toString(){}[0]
+}

compiler/util-klib-abi/testData/content/excluded_classes_1.kt

@@ -0,0 +1,19 @@
+// EXCLUDED_CLASSES: one.two/Foo three.four/Bar five.six/Baz
+
+package excluded_classes.test
+
+class Foo {
+    class Nested {
+        class Nested
+    }
+}
+class Bar {
+    class Nested {
+        class Nested
+    }
+}
+class Baz {
+    class Nested {
+        class Nested
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_1.v1.txt

@@ -0,0 +1,33 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_1>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Bar.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Bar.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Bar.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Bar.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Baz.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Baz.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class excluded_classes.test/Foo { // excluded_classes.test/Foo|null[0]
+    constructor <init>() // excluded_classes.test/Foo.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Foo.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Foo.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Foo.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Foo.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_1.v2.txt

@@ -0,0 +1,33 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_1>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Bar.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Bar.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Bar.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Bar.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Baz.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Baz.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}
+final class excluded_classes.test/Foo { // excluded_classes.test/Foo|null[0]
+    constructor <init>() // excluded_classes.test/Foo.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Foo.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Foo.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Foo.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Foo.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_2.kt

@@ -0,0 +1,19 @@
+// EXCLUDED_CLASSES: one.two/Foo three.four/Bar excluded_classes.test/Foo excluded_classes.test/Bar.Nested excluded_classes.test/Baz.Nested.Nested five.six/Baz
+
+package excluded_classes.test
+
+class Foo {
+    class Nested {
+        class Nested
+    }
+}
+class Bar {
+    class Nested {
+        class Nested
+    }
+}
+class Baz {
+    class Nested {
+        class Nested
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_2.v1.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_2>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|-5645683436151566731[0]
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|-5645683436151566731[0]
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_2.v2.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_2>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|<init>(){}[0]
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|<init>(){}[0]
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_3.kt

@@ -0,0 +1,17 @@
+// EXCLUDED_CLASSES: one.two/Foo three.four/Bar /Foo /Bar.Nested /Baz.Nested.Nested five.six/Baz
+
+class Foo {
+    class Nested {
+        class Nested
+    }
+}
+class Bar {
+    class Nested {
+        class Nested
+    }
+}
+class Baz {
+    class Nested {
+        class Nested
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_3.v1.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_3>
+final class /Bar { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|-5645683436151566731[0]
+}
+final class /Baz { // /Baz|null[0]
+    constructor <init>() // /Baz.<init>|-5645683436151566731[0]
+    final class Nested { // /Baz.Nested|null[0]
+        constructor <init>() // /Baz.Nested.<init>|-5645683436151566731[0]
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_3.v2.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_3>
+final class /Bar { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|<init>(){}[0]
+}
+final class /Baz { // /Baz|null[0]
+    constructor <init>() // /Baz.<init>|<init>(){}[0]
+    final class Nested { // /Baz.Nested|null[0]
+        constructor <init>() // /Baz.Nested.<init>|<init>(){}[0]
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_unspecified.kt

@@ -0,0 +1,19 @@
+// EXCLUDED_CLASSES:
+
+package excluded_classes.test
+
+class Foo {
+    class Nested {
+        class Nested
+    }
+}
+class Bar {
+    class Nested {
+        class Nested
+    }
+}
+class Baz {
+    class Nested {
+        class Nested
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_unspecified.v1.txt

@@ -0,0 +1,33 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_unspecified>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Bar.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Bar.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Bar.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Bar.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Baz.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Baz.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class excluded_classes.test/Foo { // excluded_classes.test/Foo|null[0]
+    constructor <init>() // excluded_classes.test/Foo.<init>|-5645683436151566731[0]
+    final class Nested { // excluded_classes.test/Foo.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Foo.Nested.<init>|-5645683436151566731[0]
+        final class Nested { // excluded_classes.test/Foo.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Foo.Nested.Nested.<init>|-5645683436151566731[0]
+        }
+    }
+}

compiler/util-klib-abi/testData/content/excluded_classes_unspecified.v2.txt

@@ -0,0 +1,33 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_classes_unspecified>
+final class excluded_classes.test/Bar { // excluded_classes.test/Bar|null[0]
+    constructor <init>() // excluded_classes.test/Bar.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Bar.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Bar.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Bar.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Bar.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}
+final class excluded_classes.test/Baz { // excluded_classes.test/Baz|null[0]
+    constructor <init>() // excluded_classes.test/Baz.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Baz.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Baz.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Baz.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Baz.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}
+final class excluded_classes.test/Foo { // excluded_classes.test/Foo|null[0]
+    constructor <init>() // excluded_classes.test/Foo.<init>|<init>(){}[0]
+    final class Nested { // excluded_classes.test/Foo.Nested|null[0]
+        constructor <init>() // excluded_classes.test/Foo.Nested.<init>|<init>(){}[0]
+        final class Nested { // excluded_classes.test/Foo.Nested.Nested|null[0]
+            constructor <init>() // excluded_classes.test/Foo.Nested.Nested.<init>|<init>(){}[0]
+        }
+    }
+}

compiler/util-klib-abi/testData/content/excluded_packages_non_root_1.kt

@@ -0,0 +1,7 @@
+// EXCLUDED_PACKAGES: one.two three.four excluded_packages.test five.six
+
+package excluded_packages.test
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_non_root_1.v1.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_1>

compiler/util-klib-abi/testData/content/excluded_packages_non_root_1.v2.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_1>

compiler/util-klib-abi/testData/content/excluded_packages_non_root_2.kt

@@ -0,0 +1,7 @@
+// EXCLUDED_PACKAGES: one.two three.four excluded_packages five.six
+
+package excluded_packages.test
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_non_root_2.v1.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_2>

compiler/util-klib-abi/testData/content/excluded_packages_non_root_2.v2.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_2>

compiler/util-klib-abi/testData/content/excluded_packages_non_root_3.kt

@@ -0,0 +1,7 @@
+// EXCLUDED_PACKAGES: one.two three.four excluded_packages_ five.six
+
+package excluded_packages.test
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_non_root_3.v1.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_3>
+final class excluded_packages.test/Class { // excluded_packages.test/Class|null[0]
+    constructor <init>() // excluded_packages.test/Class.<init>|-5645683436151566731[0]
+}
+final val excluded_packages.test/property // excluded_packages.test/property|4634558160746314112[0]
+    final fun <get-property>(): kotlin/String // excluded_packages.test/property.<get-property>|4838831487146901942[0]
+final fun excluded_packages.test/function(): kotlin/String // excluded_packages.test/function|-3322893411126713785[0]

compiler/util-klib-abi/testData/content/excluded_packages_non_root_3.v2.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_3>
+final class excluded_packages.test/Class { // excluded_packages.test/Class|null[0]
+    constructor <init>() // excluded_packages.test/Class.<init>|<init>(){}[0]
+}
+final val excluded_packages.test/property // excluded_packages.test/property|{}property[0]
+    final fun <get-property>(): kotlin/String // excluded_packages.test/property.<get-property>|<get-property>(){}[0]
+final fun excluded_packages.test/function(): kotlin/String // excluded_packages.test/function|function(){}[0]

compiler/util-klib-abi/testData/content/excluded_packages_non_root_4.kt

@@ -0,0 +1,7 @@
+// EXCLUDED_PACKAGES: one.two three.four excluded_packages_non_root_ five.six
+
+package excluded_packages.test
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_non_root_4.v1.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_4>
+final class excluded_packages.test/Class { // excluded_packages.test/Class|null[0]
+    constructor <init>() // excluded_packages.test/Class.<init>|-5645683436151566731[0]
+}
+final val excluded_packages.test/property // excluded_packages.test/property|4634558160746314112[0]
+    final fun <get-property>(): kotlin/String // excluded_packages.test/property.<get-property>|4838831487146901942[0]
+final fun excluded_packages.test/function(): kotlin/String // excluded_packages.test/function|-3322893411126713785[0]

compiler/util-klib-abi/testData/content/excluded_packages_non_root_4.v2.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_non_root_4>
+final class excluded_packages.test/Class { // excluded_packages.test/Class|null[0]
+    constructor <init>() // excluded_packages.test/Class.<init>|<init>(){}[0]
+}
+final val excluded_packages.test/property // excluded_packages.test/property|{}property[0]
+    final fun <get-property>(): kotlin/String // excluded_packages.test/property.<get-property>|<get-property>(){}[0]
+final fun excluded_packages.test/function(): kotlin/String // excluded_packages.test/function|function(){}[0]

compiler/util-klib-abi/testData/content/excluded_packages_root_1.kt

@@ -0,0 +1,5 @@
+// EXCLUDED_PACKAGES: one.two three.four "" five.six
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_root_1.v1.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_root_1>

compiler/util-klib-abi/testData/content/excluded_packages_root_1.v2.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_root_1>

compiler/util-klib-abi/testData/content/excluded_packages_root_2.kt

@@ -0,0 +1,7 @@
+// EXCLUDED_PACKAGES: one.two three.four "" five.six
+
+package excluded_packages.test
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_root_2.v1.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_root_2>

compiler/util-klib-abi/testData/content/excluded_packages_root_2.v2.txt

@@ -0,0 +1,6 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_root_2>

compiler/util-klib-abi/testData/content/excluded_packages_unspecified.kt

@@ -0,0 +1,5 @@
+// EXCLUDED_PACKAGES:
+
+class Class
+fun function(): String = ""
+val property: String get() = ""

compiler/util-klib-abi/testData/content/excluded_packages_unspecified.v1.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_unspecified>
+final class /Class { // /Class|null[0]
+    constructor <init>() // /Class.<init>|-5645683436151566731[0]
+}
+final val /property // /property|4634558160746314112[0]
+    final fun <get-property>(): kotlin/String // /property.<get-property>|4838831487146901942[0]
+final fun /function(): kotlin/String // /function|-3322893411126713785[0]

compiler/util-klib-abi/testData/content/excluded_packages_unspecified.v2.txt

@@ -0,0 +1,12 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testExcluded_packages_unspecified>
+final class /Class { // /Class|null[0]
+    constructor <init>() // /Class.<init>|<init>(){}[0]
+}
+final val /property // /property|{}property[0]
+    final fun <get-property>(): kotlin/String // /property.<get-property>|<get-property>(){}[0]
+final fun /function(): kotlin/String // /function|function(){}[0]

compiler/util-klib-abi/testData/content/inheritance.kt

@@ -0,0 +1,188 @@
+package classifiers.inheritance
+
+final class FinalClass {
+    val finalVal: String get() = ""
+    var finalVar: String get() = ""
+        set(_) = Unit
+    fun finalFun(): String = ""
+}
+
+open class OpenClass {
+    open val openVal: String get() = ""
+    val finalVal: String get() = ""
+    open var openVar: String get() = ""
+        set(_) = Unit
+    var finalVar: String get() = ""
+        set(_) = Unit
+    open fun openFun(): String = ""
+    fun finalFun(): String = ""
+}
+
+open class OpenClassImpl1 : OpenClass() {
+    override val openVal get() = ""
+    override var openVar get() = ""
+        set(_) = Unit
+    override fun openFun() = ""
+}
+open class OpenClassImpl2 : OpenClass() {
+    final override val openVal get() = ""
+    final override var openVar get() = ""
+        set(_) = Unit
+    final override fun openFun() = ""
+}
+class OpenClassImpl3 : OpenClass() {
+    override val openVal get() = ""
+    override var openVar get() = ""
+        set(_) = Unit
+    override fun openFun() = ""
+}
+class OpenClassImpl4 : OpenClass() {
+    final override val openVal get() = ""
+    final override var openVar get() = ""
+        set(_) = Unit
+    final override fun openFun() = ""
+}
+
+abstract class AbstractClass {
+    abstract val abstractVal: String
+    open val openVal: String get() = ""
+    val finalVal: String get() = ""
+    abstract var abstractVar: String
+    open var openVar: String get() = ""
+        set(_) = Unit
+    var finalVar: String get() = ""
+        set(_) = Unit
+    abstract fun abstractFun(): String
+    open fun openFun(): String = ""
+    fun finalFun(): String = ""
+}
+
+abstract class AbstractClassImpl1 : AbstractClass() {
+    override val abstractVal get() = ""
+    override val openVal get() = ""
+    override var abstractVar get() = ""
+        set(_) = Unit
+    override var openVar get() = ""
+        set(_) = Unit
+    override fun abstractFun() = ""
+    override fun openFun() = ""
+}
+abstract class AbstractClassImpl2 : AbstractClass() {
+    final override val abstractVal get() = ""
+    final override val openVal get() = ""
+    final override var abstractVar get() = ""
+        set(_) = Unit
+    final override var openVar get() = ""
+        set(_) = Unit
+    final override fun abstractFun() = ""
+    final override fun openFun() = ""
+}
+final class AbstractClassImpl3 : AbstractClass() {
+    override val abstractVal get() = ""
+    override val openVal get() = ""
+    override var abstractVar get() = ""
+        set(_) = Unit
+    override var openVar get() = ""
+        set(_) = Unit
+    override fun abstractFun() = ""
+    override fun openFun() = ""
+}
+final class AbstractClassImpl4 : AbstractClass() {
+    final override val abstractVal get() = ""
+    final override val openVal get() = ""
+    final override var abstractVar get() = ""
+        set(_) = Unit
+    final override var openVar get() = ""
+        set(_) = Unit
+    final override fun abstractFun() = ""
+    final override fun openFun() = ""
+}
+
+interface Interface1 {
+    val abstractVal1: String
+    val openVal1: String get() = ""
+    fun abstractFun1(): String
+    fun openFun1(): String = ""
+}
+
+interface Interface2 {
+    val abstractVal2: String
+    val openVal2: String get() = ""
+    fun abstractFun2(): String
+    fun openFun2(): String = ""
+}
+
+class MultiInheritance_OpenClass_Interface1_Interface2: OpenClass(), Interface1, Interface2 {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+class MultiInheritance_OpenClass_Interface2_Interface1: OpenClass(), Interface2, Interface1 {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+class MultiInheritance_Interface1_OpenClass_Interface2: Interface1, OpenClass(), Interface2 {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+class MultiInheritance_Interface2_OpenClass_Interface1: Interface2, OpenClass(), Interface1 {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+class MultiInheritance_Interface1_Interface2_OpenClass: Interface1, Interface2, OpenClass() {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+class MultiInheritance_Interface2_Interface1_OpenClass: Interface2, Interface1, OpenClass() {
+    override val abstractVal1 get() = ""
+    override val abstractVal2 get() = ""
+    override fun abstractFun1() = ""
+    override fun abstractFun2() = ""
+}
+
+open class OpenClassWithTypeParameters<P, Q>
+class OpenClassWithTypeParametersImpl_Int_String : OpenClassWithTypeParameters<Int, String>()
+class OpenClassWithTypeParametersImpl_NInt_NString : OpenClassWithTypeParameters<Int?, String?>()
+class OpenClassWithTypeParametersImpl_String_Int : OpenClassWithTypeParameters<String, Int>()
+class OpenClassWithTypeParametersImpl_T1_T2<T1, T2> : OpenClassWithTypeParameters<T1, T2>()
+class OpenClassWithTypeParametersImpl_T2_T1<T2, T1> : OpenClassWithTypeParameters<T1, T2>()
+class OpenClassWithTypeParametersImpl_T1_Number_T2_CS<T1 : Number, T2 : CharSequence> : OpenClassWithTypeParameters<T1, T2>()
+class OpenClassWithTypeParametersImpl_DNNT1_DNNT2<T1, T2> : OpenClassWithTypeParameters<T1 & Any, T2 & Any>()
+
+public interface PublicInterface {
+    public fun publicDefaultFunInPublicInterface(): String = ""
+    private fun privateDefaultFunInPublicInterface(): String = ""
+}
+internal interface InternalInterface {
+    public fun publicDefaultFunInInternalInterface(): String = ""
+    private fun privateDefaultFunInInternalInterface(): String = ""
+}
+private interface PrivateInterface {
+    public fun publicDefaultFunInPrivateInterface(): String = ""
+    private fun privateDefaultFunInPrivateInterface(): String = ""
+}
+class ClassThatInheritsDefaultImplsFromInterfaces : PublicInterface, InternalInterface, PrivateInterface
+
+sealed class SealedClass {
+    class SealedClass_Subclass1 : SealedClass()
+}
+class SealedClass_Subclass2 : SealedClass()
+
+sealed interface SealedInterface {
+    class SealedInterface_Subclass1 : SealedInterface
+}
+class SealedInterface_Subclass2 : SealedInterface

compiler/util-klib-abi/testData/content/inheritance.v1.txt

@@ -0,0 +1,264 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testInheritance>
+abstract class classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClass|null[0]
+    abstract val abstractVal // classifiers.inheritance/AbstractClass.abstractVal|2000751617811374017[0]
+        abstract fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClass.abstractVal.<get-abstractVal>|-836793625462255519[0]
+    abstract var abstractVar // classifiers.inheritance/AbstractClass.abstractVar|-2520811489168320452[0]
+        abstract fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClass.abstractVar.<get-abstractVar>|7559126596100066971[0]
+        abstract fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClass.abstractVar.<set-abstractVar>|-8164821299376681880[0]
+    final val finalVal // classifiers.inheritance/AbstractClass.finalVal|5394461552232296518[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/AbstractClass.finalVal.<get-finalVal>|-2800634045661637469[0]
+    final var finalVar // classifiers.inheritance/AbstractClass.finalVar|-5135497273132398902[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/AbstractClass.finalVar.<get-finalVar>|-2673957050545090222[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/AbstractClass.finalVar.<set-finalVar>|2433614443812258676[0]
+    open val openVal // classifiers.inheritance/AbstractClass.openVal|-8290413087783741973[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClass.openVal.<get-openVal>|-2274898585098549815[0]
+    open var openVar // classifiers.inheritance/AbstractClass.openVar|1159668422303200935[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClass.openVar.<get-openVar>|762747603021644427[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClass.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/AbstractClass.<init>|-5645683436151566731[0]
+    abstract fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClass.abstractFun|-8137574360252002020[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/AbstractClass.finalFun|3657632771909858561[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/AbstractClass.openFun|-1313199406532640622[0]
+}
+abstract class classifiers.inheritance/AbstractClassImpl1 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl1|null[0]
+    open val abstractVal // classifiers.inheritance/AbstractClassImpl1.abstractVal|2000751617811374017[0]
+        open fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractVal.<get-abstractVal>|-836793625462255519[0]
+    open var abstractVar // classifiers.inheritance/AbstractClassImpl1.abstractVar|-2520811489168320452[0]
+        open fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractVar.<get-abstractVar>|7559126596100066971[0]
+        open fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl1.abstractVar.<set-abstractVar>|-8164821299376681880[0]
+    open val openVal // classifiers.inheritance/AbstractClassImpl1.openVal|-8290413087783741973[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openVal.<get-openVal>|-2274898585098549815[0]
+    open var openVar // classifiers.inheritance/AbstractClassImpl1.openVar|1159668422303200935[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openVar.<get-openVar>|762747603021644427[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl1.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl1.<init>|-5645683436151566731[0]
+    open fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractFun|-8137574360252002020[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openFun|-1313199406532640622[0]
+}
+abstract class classifiers.inheritance/AbstractClassImpl2 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl2|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl2.abstractVal|2000751617811374017[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractVal.<get-abstractVal>|-836793625462255519[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl2.abstractVar|-2520811489168320452[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractVar.<get-abstractVar>|7559126596100066971[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl2.abstractVar.<set-abstractVar>|-8164821299376681880[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl2.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl2.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl2.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl2.<init>|-5645683436151566731[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractFun|-8137574360252002020[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openFun|-1313199406532640622[0]
+}
+final class classifiers.inheritance/AbstractClassImpl3 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl3|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl3.abstractVal|2000751617811374017[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractVal.<get-abstractVal>|-836793625462255519[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl3.abstractVar|-2520811489168320452[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractVar.<get-abstractVar>|7559126596100066971[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl3.abstractVar.<set-abstractVar>|-8164821299376681880[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl3.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl3.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl3.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl3.<init>|-5645683436151566731[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractFun|-8137574360252002020[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openFun|-1313199406532640622[0]
+}
+final class classifiers.inheritance/AbstractClassImpl4 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl4|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl4.abstractVal|2000751617811374017[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractVal.<get-abstractVal>|-836793625462255519[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl4.abstractVar|-2520811489168320452[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractVar.<get-abstractVar>|7559126596100066971[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl4.abstractVar.<set-abstractVar>|-8164821299376681880[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl4.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl4.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl4.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl4.<init>|-5645683436151566731[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractFun|-8137574360252002020[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openFun|-1313199406532640622[0]
+}
+final class classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces : classifiers.inheritance/InternalInterface, classifiers.inheritance/PublicInterface { // classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces|null[0]
+    constructor <init>() // classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces.<init>|-5645683436151566731[0]
+}
+final class classifiers.inheritance/FinalClass { // classifiers.inheritance/FinalClass|null[0]
+    final val finalVal // classifiers.inheritance/FinalClass.finalVal|5394461552232296518[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/FinalClass.finalVal.<get-finalVal>|-2800634045661637469[0]
+    final var finalVar // classifiers.inheritance/FinalClass.finalVar|-5135497273132398902[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/FinalClass.finalVar.<get-finalVar>|-2673957050545090222[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/FinalClass.finalVar.<set-finalVar>|2433614443812258676[0]
+    constructor <init>() // classifiers.inheritance/FinalClass.<init>|-5645683436151566731[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/FinalClass.finalFun|3657632771909858561[0]
+}
+abstract interface classifiers.inheritance/Interface1 { // classifiers.inheritance/Interface1|null[0]
+    abstract val abstractVal1 // classifiers.inheritance/Interface1.abstractVal1|7480474675272340917[0]
+        abstract fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/Interface1.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    open val openVal1 // classifiers.inheritance/Interface1.openVal1|-7581873392553976764[0]
+        open fun <get-openVal1>(): kotlin/String // classifiers.inheritance/Interface1.openVal1.<get-openVal1>|-6354332572500305077[0]
+    abstract fun abstractFun1(): kotlin/String // classifiers.inheritance/Interface1.abstractFun1|6423930018466193193[0]
+    open fun openFun1(): kotlin/String // classifiers.inheritance/Interface1.openFun1|-6191809905018816441[0]
+}
+abstract interface classifiers.inheritance/Interface2 { // classifiers.inheritance/Interface2|null[0]
+    abstract val abstractVal2 // classifiers.inheritance/Interface2.abstractVal2|-2901479426346377967[0]
+        abstract fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/Interface2.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    open val openVal2 // classifiers.inheritance/Interface2.openVal2|-8176207972376961391[0]
+        open fun <get-openVal2>(): kotlin/String // classifiers.inheritance/Interface2.openVal2.<get-openVal2>|-2369003083313268441[0]
+    abstract fun abstractFun2(): kotlin/String // classifiers.inheritance/Interface2.abstractFun2|-4887182853009098333[0]
+    open fun openFun2(): kotlin/String // classifiers.inheritance/Interface2.openFun2|-6569900631812216745[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractFun2|-4887182853009098333[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractFun2|-4887182853009098333[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractFun2|-4887182853009098333[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractFun2|-4887182853009098333[0]
+}
+final class classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractFun2|-4887182853009098333[0]
+}
+final class classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal1|7480474675272340917[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal1.<get-abstractVal1>|8439928819663930766[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal2|-2901479426346377967[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal2.<get-abstractVal2>|2515504098830302866[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.<init>|-5645683436151566731[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractFun1|6423930018466193193[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractFun2|-4887182853009098333[0]
+}
+open class classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClass|null[0]
+    final val finalVal // classifiers.inheritance/OpenClass.finalVal|5394461552232296518[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/OpenClass.finalVal.<get-finalVal>|-2800634045661637469[0]
+    final var finalVar // classifiers.inheritance/OpenClass.finalVar|-5135497273132398902[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/OpenClass.finalVar.<get-finalVar>|-2673957050545090222[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/OpenClass.finalVar.<set-finalVar>|2433614443812258676[0]
+    open val openVal // classifiers.inheritance/OpenClass.openVal|-8290413087783741973[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClass.openVal.<get-openVal>|-2274898585098549815[0]
+    open var openVar // classifiers.inheritance/OpenClass.openVar|1159668422303200935[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClass.openVar.<get-openVar>|762747603021644427[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClass.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/OpenClass.<init>|-5645683436151566731[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/OpenClass.finalFun|3657632771909858561[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/OpenClass.openFun|-1313199406532640622[0]
+}
+open class classifiers.inheritance/OpenClassImpl1 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl1|null[0]
+    open val openVal // classifiers.inheritance/OpenClassImpl1.openVal|-8290413087783741973[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openVal.<get-openVal>|-2274898585098549815[0]
+    open var openVar // classifiers.inheritance/OpenClassImpl1.openVar|1159668422303200935[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openVar.<get-openVar>|762747603021644427[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl1.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl1.<init>|-5645683436151566731[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openFun|-1313199406532640622[0]
+}
+open class classifiers.inheritance/OpenClassImpl2 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl2|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl2.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl2.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl2.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl2.<init>|-5645683436151566731[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openFun|-1313199406532640622[0]
+}
+final class classifiers.inheritance/OpenClassImpl3 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl3|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl3.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl3.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl3.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl3.<init>|-5645683436151566731[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openFun|-1313199406532640622[0]
+}
+final class classifiers.inheritance/OpenClassImpl4 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl4|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl4.openVal|-8290413087783741973[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openVal.<get-openVal>|-2274898585098549815[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl4.openVar|1159668422303200935[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openVar.<get-openVar>|762747603021644427[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl4.openVar.<set-openVar>|-11233939626029810[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl4.<init>|-5645683436151566731[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openFun|-1313199406532640622[0]
+}
+open class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParameters { // classifiers.inheritance/OpenClassWithTypeParameters|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParameters.<init>|-5645683436151566731[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2 : classifiers.inheritance/OpenClassWithTypeParameters<#A!!, #B!!> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2.<init>|-5645683436151566731[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/Int, kotlin/String> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String.<init>|-5645683436151566731[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/Int?, kotlin/String?> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString.<init>|-5645683436151566731[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/String, kotlin/Int> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int.<init>|-5645683436151566731[0]
+}
+final class <#A: kotlin/Number, #B: kotlin/CharSequence> classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS : classifiers.inheritance/OpenClassWithTypeParameters<#A, #B> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS.<init>|-5645683436151566731[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2 : classifiers.inheritance/OpenClassWithTypeParameters<#A, #B> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2.<init>|-5645683436151566731[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1 : classifiers.inheritance/OpenClassWithTypeParameters<#B, #A> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1.<init>|-5645683436151566731[0]
+}
+abstract interface classifiers.inheritance/PublicInterface { // classifiers.inheritance/PublicInterface|null[0]
+    open fun publicDefaultFunInPublicInterface(): kotlin/String // classifiers.inheritance/PublicInterface.publicDefaultFunInPublicInterface|2012864992434792153[0]
+}
+sealed class classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass|null[0]
+    constructor <init>() // classifiers.inheritance/SealedClass.<init>|-5645683436151566731[0]
+    final class SealedClass_Subclass1 : classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass.SealedClass_Subclass1|null[0]
+        constructor <init>() // classifiers.inheritance/SealedClass.SealedClass_Subclass1.<init>|-5645683436151566731[0]
+    }
+}
+final class classifiers.inheritance/SealedClass_Subclass2 : classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass_Subclass2|null[0]
+    constructor <init>() // classifiers.inheritance/SealedClass_Subclass2.<init>|-5645683436151566731[0]
+}
+sealed interface classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface|null[0]
+    final class SealedInterface_Subclass1 : classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface.SealedInterface_Subclass1|null[0]
+        constructor <init>() // classifiers.inheritance/SealedInterface.SealedInterface_Subclass1.<init>|-5645683436151566731[0]
+    }
+}
+final class classifiers.inheritance/SealedInterface_Subclass2 : classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface_Subclass2|null[0]
+    constructor <init>() // classifiers.inheritance/SealedInterface_Subclass2.<init>|-5645683436151566731[0]
+}

compiler/util-klib-abi/testData/content/inheritance.v2.txt

@@ -0,0 +1,264 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testInheritance>
+abstract class classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClass|null[0]
+    abstract val abstractVal // classifiers.inheritance/AbstractClass.abstractVal|{}abstractVal[0]
+        abstract fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClass.abstractVal.<get-abstractVal>|<get-abstractVal>(){}[0]
+    abstract var abstractVar // classifiers.inheritance/AbstractClass.abstractVar|{}abstractVar[0]
+        abstract fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClass.abstractVar.<get-abstractVar>|<get-abstractVar>(){}[0]
+        abstract fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClass.abstractVar.<set-abstractVar>|<set-abstractVar>(kotlin.String){}[0]
+    final val finalVal // classifiers.inheritance/AbstractClass.finalVal|{}finalVal[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/AbstractClass.finalVal.<get-finalVal>|<get-finalVal>(){}[0]
+    final var finalVar // classifiers.inheritance/AbstractClass.finalVar|{}finalVar[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/AbstractClass.finalVar.<get-finalVar>|<get-finalVar>(){}[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/AbstractClass.finalVar.<set-finalVar>|<set-finalVar>(kotlin.String){}[0]
+    open val openVal // classifiers.inheritance/AbstractClass.openVal|{}openVal[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClass.openVal.<get-openVal>|<get-openVal>(){}[0]
+    open var openVar // classifiers.inheritance/AbstractClass.openVar|{}openVar[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClass.openVar.<get-openVar>|<get-openVar>(){}[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClass.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/AbstractClass.<init>|<init>(){}[0]
+    abstract fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClass.abstractFun|abstractFun(){}[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/AbstractClass.finalFun|finalFun(){}[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/AbstractClass.openFun|openFun(){}[0]
+}
+abstract class classifiers.inheritance/AbstractClassImpl1 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl1|null[0]
+    open val abstractVal // classifiers.inheritance/AbstractClassImpl1.abstractVal|{}abstractVal[0]
+        open fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractVal.<get-abstractVal>|<get-abstractVal>(){}[0]
+    open var abstractVar // classifiers.inheritance/AbstractClassImpl1.abstractVar|{}abstractVar[0]
+        open fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractVar.<get-abstractVar>|<get-abstractVar>(){}[0]
+        open fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl1.abstractVar.<set-abstractVar>|<set-abstractVar>(kotlin.String){}[0]
+    open val openVal // classifiers.inheritance/AbstractClassImpl1.openVal|{}openVal[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openVal.<get-openVal>|<get-openVal>(){}[0]
+    open var openVar // classifiers.inheritance/AbstractClassImpl1.openVar|{}openVar[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openVar.<get-openVar>|<get-openVar>(){}[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl1.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl1.<init>|<init>(){}[0]
+    open fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.abstractFun|abstractFun(){}[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl1.openFun|openFun(){}[0]
+}
+abstract class classifiers.inheritance/AbstractClassImpl2 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl2|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl2.abstractVal|{}abstractVal[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractVal.<get-abstractVal>|<get-abstractVal>(){}[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl2.abstractVar|{}abstractVar[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractVar.<get-abstractVar>|<get-abstractVar>(){}[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl2.abstractVar.<set-abstractVar>|<set-abstractVar>(kotlin.String){}[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl2.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl2.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl2.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl2.<init>|<init>(){}[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.abstractFun|abstractFun(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl2.openFun|openFun(){}[0]
+}
+final class classifiers.inheritance/AbstractClassImpl3 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl3|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl3.abstractVal|{}abstractVal[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractVal.<get-abstractVal>|<get-abstractVal>(){}[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl3.abstractVar|{}abstractVar[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractVar.<get-abstractVar>|<get-abstractVar>(){}[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl3.abstractVar.<set-abstractVar>|<set-abstractVar>(kotlin.String){}[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl3.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl3.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl3.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl3.<init>|<init>(){}[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.abstractFun|abstractFun(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl3.openFun|openFun(){}[0]
+}
+final class classifiers.inheritance/AbstractClassImpl4 : classifiers.inheritance/AbstractClass { // classifiers.inheritance/AbstractClassImpl4|null[0]
+    final val abstractVal // classifiers.inheritance/AbstractClassImpl4.abstractVal|{}abstractVal[0]
+        final fun <get-abstractVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractVal.<get-abstractVal>|<get-abstractVal>(){}[0]
+    final var abstractVar // classifiers.inheritance/AbstractClassImpl4.abstractVar|{}abstractVar[0]
+        final fun <get-abstractVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractVar.<get-abstractVar>|<get-abstractVar>(){}[0]
+        final fun <set-abstractVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl4.abstractVar.<set-abstractVar>|<set-abstractVar>(kotlin.String){}[0]
+    final val openVal // classifiers.inheritance/AbstractClassImpl4.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/AbstractClassImpl4.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/AbstractClassImpl4.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/AbstractClassImpl4.<init>|<init>(){}[0]
+    final fun abstractFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.abstractFun|abstractFun(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/AbstractClassImpl4.openFun|openFun(){}[0]
+}
+final class classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces : classifiers.inheritance/InternalInterface, classifiers.inheritance/PublicInterface { // classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces|null[0]
+    constructor <init>() // classifiers.inheritance/ClassThatInheritsDefaultImplsFromInterfaces.<init>|<init>(){}[0]
+}
+final class classifiers.inheritance/FinalClass { // classifiers.inheritance/FinalClass|null[0]
+    final val finalVal // classifiers.inheritance/FinalClass.finalVal|{}finalVal[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/FinalClass.finalVal.<get-finalVal>|<get-finalVal>(){}[0]
+    final var finalVar // classifiers.inheritance/FinalClass.finalVar|{}finalVar[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/FinalClass.finalVar.<get-finalVar>|<get-finalVar>(){}[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/FinalClass.finalVar.<set-finalVar>|<set-finalVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/FinalClass.<init>|<init>(){}[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/FinalClass.finalFun|finalFun(){}[0]
+}
+abstract interface classifiers.inheritance/Interface1 { // classifiers.inheritance/Interface1|null[0]
+    abstract val abstractVal1 // classifiers.inheritance/Interface1.abstractVal1|{}abstractVal1[0]
+        abstract fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/Interface1.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    open val openVal1 // classifiers.inheritance/Interface1.openVal1|{}openVal1[0]
+        open fun <get-openVal1>(): kotlin/String // classifiers.inheritance/Interface1.openVal1.<get-openVal1>|<get-openVal1>(){}[0]
+    abstract fun abstractFun1(): kotlin/String // classifiers.inheritance/Interface1.abstractFun1|abstractFun1(){}[0]
+    open fun openFun1(): kotlin/String // classifiers.inheritance/Interface1.openFun1|openFun1(){}[0]
+}
+abstract interface classifiers.inheritance/Interface2 { // classifiers.inheritance/Interface2|null[0]
+    abstract val abstractVal2 // classifiers.inheritance/Interface2.abstractVal2|{}abstractVal2[0]
+        abstract fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/Interface2.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    open val openVal2 // classifiers.inheritance/Interface2.openVal2|{}openVal2[0]
+        open fun <get-openVal2>(): kotlin/String // classifiers.inheritance/Interface2.openVal2.<get-openVal2>|<get-openVal2>(){}[0]
+    abstract fun abstractFun2(): kotlin/String // classifiers.inheritance/Interface2.abstractFun2|abstractFun2(){}[0]
+    open fun openFun2(): kotlin/String // classifiers.inheritance/Interface2.openFun2|openFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_Interface2_OpenClass.abstractFun2|abstractFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface1_OpenClass_Interface2.abstractFun2|abstractFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_Interface1_OpenClass.abstractFun2|abstractFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_Interface2_OpenClass_Interface1.abstractFun2|abstractFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface1_Interface2.abstractFun2|abstractFun2(){}[0]
+}
+final class classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1 : classifiers.inheritance/Interface1, classifiers.inheritance/Interface2, classifiers.inheritance/OpenClass { // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1|null[0]
+    final val abstractVal1 // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal1|{}abstractVal1[0]
+        final fun <get-abstractVal1>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal1.<get-abstractVal1>|<get-abstractVal1>(){}[0]
+    final val abstractVal2 // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal2|{}abstractVal2[0]
+        final fun <get-abstractVal2>(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractVal2.<get-abstractVal2>|<get-abstractVal2>(){}[0]
+    constructor <init>() // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.<init>|<init>(){}[0]
+    final fun abstractFun1(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractFun1|abstractFun1(){}[0]
+    final fun abstractFun2(): kotlin/String // classifiers.inheritance/MultiInheritance_OpenClass_Interface2_Interface1.abstractFun2|abstractFun2(){}[0]
+}
+open class classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClass|null[0]
+    final val finalVal // classifiers.inheritance/OpenClass.finalVal|{}finalVal[0]
+        final fun <get-finalVal>(): kotlin/String // classifiers.inheritance/OpenClass.finalVal.<get-finalVal>|<get-finalVal>(){}[0]
+    final var finalVar // classifiers.inheritance/OpenClass.finalVar|{}finalVar[0]
+        final fun <get-finalVar>(): kotlin/String // classifiers.inheritance/OpenClass.finalVar.<get-finalVar>|<get-finalVar>(){}[0]
+        final fun <set-finalVar>(kotlin/String) // classifiers.inheritance/OpenClass.finalVar.<set-finalVar>|<set-finalVar>(kotlin.String){}[0]
+    open val openVal // classifiers.inheritance/OpenClass.openVal|{}openVal[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClass.openVal.<get-openVal>|<get-openVal>(){}[0]
+    open var openVar // classifiers.inheritance/OpenClass.openVar|{}openVar[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClass.openVar.<get-openVar>|<get-openVar>(){}[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClass.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/OpenClass.<init>|<init>(){}[0]
+    final fun finalFun(): kotlin/String // classifiers.inheritance/OpenClass.finalFun|finalFun(){}[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/OpenClass.openFun|openFun(){}[0]
+}
+open class classifiers.inheritance/OpenClassImpl1 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl1|null[0]
+    open val openVal // classifiers.inheritance/OpenClassImpl1.openVal|{}openVal[0]
+        open fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openVal.<get-openVal>|<get-openVal>(){}[0]
+    open var openVar // classifiers.inheritance/OpenClassImpl1.openVar|{}openVar[0]
+        open fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openVar.<get-openVar>|<get-openVar>(){}[0]
+        open fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl1.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl1.<init>|<init>(){}[0]
+    open fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl1.openFun|openFun(){}[0]
+}
+open class classifiers.inheritance/OpenClassImpl2 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl2|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl2.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl2.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl2.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl2.<init>|<init>(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl2.openFun|openFun(){}[0]
+}
+final class classifiers.inheritance/OpenClassImpl3 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl3|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl3.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl3.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl3.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl3.<init>|<init>(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl3.openFun|openFun(){}[0]
+}
+final class classifiers.inheritance/OpenClassImpl4 : classifiers.inheritance/OpenClass { // classifiers.inheritance/OpenClassImpl4|null[0]
+    final val openVal // classifiers.inheritance/OpenClassImpl4.openVal|{}openVal[0]
+        final fun <get-openVal>(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openVal.<get-openVal>|<get-openVal>(){}[0]
+    final var openVar // classifiers.inheritance/OpenClassImpl4.openVar|{}openVar[0]
+        final fun <get-openVar>(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openVar.<get-openVar>|<get-openVar>(){}[0]
+        final fun <set-openVar>(kotlin/String) // classifiers.inheritance/OpenClassImpl4.openVar.<set-openVar>|<set-openVar>(kotlin.String){}[0]
+    constructor <init>() // classifiers.inheritance/OpenClassImpl4.<init>|<init>(){}[0]
+    final fun openFun(): kotlin/String // classifiers.inheritance/OpenClassImpl4.openFun|openFun(){}[0]
+}
+open class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParameters { // classifiers.inheritance/OpenClassWithTypeParameters|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParameters.<init>|<init>(){}[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2 : classifiers.inheritance/OpenClassWithTypeParameters<#A!!, #B!!> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_DNNT1_DNNT2.<init>|<init>(){}[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/Int, kotlin/String> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_Int_String.<init>|<init>(){}[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/Int?, kotlin/String?> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_NInt_NString.<init>|<init>(){}[0]
+}
+final class classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int : classifiers.inheritance/OpenClassWithTypeParameters<kotlin/String, kotlin/Int> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_String_Int.<init>|<init>(){}[0]
+}
+final class <#A: kotlin/Number, #B: kotlin/CharSequence> classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS : classifiers.inheritance/OpenClassWithTypeParameters<#A, #B> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_Number_T2_CS.<init>|<init>(){}[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2 : classifiers.inheritance/OpenClassWithTypeParameters<#A, #B> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T1_T2.<init>|<init>(){}[0]
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?> classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1 : classifiers.inheritance/OpenClassWithTypeParameters<#B, #A> { // classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1|null[0]
+    constructor <init>() // classifiers.inheritance/OpenClassWithTypeParametersImpl_T2_T1.<init>|<init>(){}[0]
+}
+abstract interface classifiers.inheritance/PublicInterface { // classifiers.inheritance/PublicInterface|null[0]
+    open fun publicDefaultFunInPublicInterface(): kotlin/String // classifiers.inheritance/PublicInterface.publicDefaultFunInPublicInterface|publicDefaultFunInPublicInterface(){}[0]
+}
+sealed class classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass|null[0]
+    constructor <init>() // classifiers.inheritance/SealedClass.<init>|<init>(){}[0]
+    final class SealedClass_Subclass1 : classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass.SealedClass_Subclass1|null[0]
+        constructor <init>() // classifiers.inheritance/SealedClass.SealedClass_Subclass1.<init>|<init>(){}[0]
+    }
+}
+final class classifiers.inheritance/SealedClass_Subclass2 : classifiers.inheritance/SealedClass { // classifiers.inheritance/SealedClass_Subclass2|null[0]
+    constructor <init>() // classifiers.inheritance/SealedClass_Subclass2.<init>|<init>(){}[0]
+}
+sealed interface classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface|null[0]
+    final class SealedInterface_Subclass1 : classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface.SealedInterface_Subclass1|null[0]
+        constructor <init>() // classifiers.inheritance/SealedInterface.SealedInterface_Subclass1.<init>|<init>(){}[0]
+    }
+}
+final class classifiers.inheritance/SealedInterface_Subclass2 : classifiers.inheritance/SealedInterface { // classifiers.inheritance/SealedInterface_Subclass2|null[0]
+    constructor <init>() // classifiers.inheritance/SealedInterface_Subclass2.<init>|<init>(){}[0]
+}

compiler/util-klib-abi/testData/content/root_package.kt

@@ -0,0 +1,14 @@
+// Check how declarations from the root package are rendered.
+
+interface Interface {
+    interface NestedInterface
+}
+
+public class Class(val property: String): Interface, Interface.NestedInterface {
+    fun function(): String = ""
+    class NestedClass
+}
+
+fun function(): String = ""
+
+val property: String get() = ""

compiler/util-klib-abi/testData/content/root_package.v1.txt

@@ -0,0 +1,21 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testRoot_package>
+final class /Class : /Interface, /Interface.NestedInterface { // /Class|null[0]
+    final val property // /Class.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // /Class.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // /Class.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // /Class.function|-3322893411126713785[0]
+    final class NestedClass { // /Class.NestedClass|null[0]
+        constructor <init>() // /Class.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+abstract interface /Interface { // /Interface|null[0]
+    abstract interface NestedInterface // /Interface.NestedInterface|null[0]
+}
+final val /property // /property|4634558160746314112[0]
+    final fun <get-property>(): kotlin/String // /property.<get-property>|4838831487146901942[0]
+final fun /function(): kotlin/String // /function|-3322893411126713785[0]

compiler/util-klib-abi/testData/content/root_package.v2.txt

@@ -0,0 +1,21 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testRoot_package>
+final class /Class : /Interface, /Interface.NestedInterface { // /Class|null[0]
+    final val property // /Class.property|{}property[0]
+        final fun <get-property>(): kotlin/String // /Class.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // /Class.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // /Class.function|function(){}[0]
+    final class NestedClass { // /Class.NestedClass|null[0]
+        constructor <init>() // /Class.NestedClass.<init>|<init>(){}[0]
+    }
+}
+abstract interface /Interface { // /Interface|null[0]
+    abstract interface NestedInterface // /Interface.NestedInterface|null[0]
+}
+final val /property // /property|{}property[0]
+    final fun <get-property>(): kotlin/String // /property.<get-property>|<get-property>(){}[0]
+final fun /function(): kotlin/String // /function|function(){}[0]

compiler/util-klib-abi/testData/content/type_parameters.kt

@@ -0,0 +1,133 @@
+package type_parameters.test
+
+interface Interface<A, B, C>
+class TypeParameterInSuperTypes<A, B, C> : Interface<List<List<C>>, Map<B, A>, Triple<C, B, A>>
+
+fun <A : CharSequence, B : A, C : B> interDependentTypeParameters(p1: A, p2: B, p3: C) = Unit
+fun <A> multipleBounds(p1: A) where A : CharSequence, A : Appendable, A : Number = Unit
+
+inline fun <reified R, T> functionWithReifiedParameter(p1: R, p2: T) = Unit
+
+fun <T00, T01 : Any, T02 : CharSequence?, T03 : CharSequence, T04 : Appendable?, T05 : Appendable, T06 : Number?, T07 : Number, T08 : List<*>?, T09 : List<*>,
+     T10, T11 : Any, T12 : CharSequence?, T13 : CharSequence, T14 : Appendable?, T15 : Appendable, T16 : Number?, T17 : Number, T18 : List<*>?, T19 : List<*>,
+     T20, T21 : Any, T22 : CharSequence?, T23 : CharSequence, T24 : Appendable?, T25 : Appendable, T26 : Number?, T27 : Number, T28 : List<*>?, T29 : List<*>,
+     T30, T31 : Any, T32 : CharSequence?, T33 : CharSequence, T34 : Appendable?, T35 : Appendable, T36 : Number?, T37 : Number, T38 : List<*>?, T39 : List<*>,
+     T40, T41 : Any, T42 : CharSequence?, T43 : CharSequence, T44 : Appendable?, T45 : Appendable, T46 : Number?, T47 : Number, T48 : List<*>?, T49 : List<*>,
+     T50, T51 : Any, T52 : CharSequence?, T53 : CharSequence, T54 : Appendable?, T55 : Appendable, T56 : Number?, T57 : Number, T58 : List<*>?, T59 : List<*>> lotsOfTypeParameters(): CharSequence = ""
+
+var <P : Number> P.property: P get() = this
+    set(_) = Unit
+var <P : CharSequence> P?.property: P? get() = this
+    set(_) = Unit
+var <P : Appendable?> P.property: P get() = this
+    set(_) = Unit
+var <P : List<*>?> P?.property: P? get() = this
+    set(_) = Unit
+
+fun <F : Number> one(p1: F): F = p1
+fun <F : CharSequence> one(p1: F?): F? = p1
+fun <F : Appendable?> one(p1: F): F = p1
+fun <F : List<*>?> one(p1: F?): F? = p1
+
+class Outer<O : Appendable>(p1: O) {
+    inner class TypeParameterInSuperTypes<A, B> : Interface<List<List<O>>, Map<B, A>, Triple<O, B, A>>
+
+    var O.property: O get() = TODO()
+        set(_) = Unit
+    var <P : List<*>> P.property: P get() = TODO()
+        set(_) = Unit
+    var <P : Number> P?.property: P get() = TODO()
+        set(_) = Unit
+
+    fun one(p1: O) = Unit
+    fun <F : Number> one(p1: F) = Unit
+    fun <F : Number> two(p0: F, p1: O) = Unit
+    fun <F : Number> two(p0: O, p1: F) = Unit
+
+    class Nested<N : CharSequence>(p1: N) {
+        inner class TypeParameterInSuperTypes<A, B> : Interface<List<List<N>>, Map<B, A>, Triple<N, B, A>>
+
+        var N.property: N get() = TODO()
+            set(_) = kotlin.Unit
+        var <P : List<*>> P.property: P get() = TODO()
+            set(_) = Unit
+        var <P : Number> P?.property: P get() = TODO()
+            set(_) = Unit
+
+        fun one(p1: N) = Unit
+        fun <F : Number> one(p1: F) = Unit
+        fun <F : Number> two(p0: F, p1: N) = Unit
+        fun <F : Number> two(p0: N, p1: F) = Unit
+
+        inner class Inner<I : StringBuilder>(p1: N, p2: I) {
+            inner class TypeParameterInSuperTypes<A> : Interface<List<List<N>>, Map<I, A>, Triple<N, I, A>>
+
+            var N.property: N get() = TODO()
+                set(_) = kotlin.Unit
+            var I.property: I get() = TODO()
+                set(_) = kotlin.Unit
+            var <P : List<*>> P.property: P get() = TODO()
+                set(_) = Unit
+            var <P : Number> P?.property: P get() = TODO()
+                set(_) = Unit
+
+            fun one(p1: N) = Unit
+            fun one(p1: I) = Unit
+            fun <F : Number> one(p1: F) = Unit
+            fun two(p0: N, p1: I) = Unit
+            fun two(p0: I, p1: N) = Unit
+            fun <F : Number> two(p0: N, p1: I) = Unit
+            fun <F : Number> two(p0: N, p1: F) = Unit
+            fun <F : Number> two(p0: I, p1: N) = Unit
+            fun <F : Number> two(p0: I, p1: F) = Unit
+            fun <F : Number> two(p0: F, p1: N) = Unit
+            fun <F : Number> two(p0: F, p1: I) = Unit
+            fun <F : Number> three(p1: N, p2: I, p3: F) = Unit
+            fun <F : Number> three(p1: N, p2: F, p3: I) = Unit
+            fun <F : Number> three(p1: I, p2: N, p3: F) = Unit
+            fun <F : Number> three(p1: I, p2: F, p3: N) = Unit
+            fun <F : Number> three(p1: F, p2: N, p3: I) = Unit
+            fun <F : Number> three(p1: F, p2: I, p3: N) = Unit
+        }
+    }
+
+    inner class Inner<I : CharSequence>(p1: O, p2: I) {
+        inner class TypeParameterInSuperTypes<A> : Interface<List<List<O>>, Map<I, A>, Triple<O, I, A>>
+
+        var O.property: O get() = TODO()
+            set(_) = kotlin.Unit
+        var I.property: I get() = TODO()
+            set(_) = kotlin.Unit
+        var <P : List<*>> P.property: P get() = TODO()
+            set(_) = Unit
+        var <P : Number> P?.property: P get() = TODO()
+            set(_) = Unit
+
+        fun one(p1: O) = Unit
+        fun one(p1: I) = Unit
+        fun <F : Number> one(p1: F) = Unit
+        fun two(p0: O, p1: I) = Unit
+        fun two(p0: I, p1: O) = Unit
+        fun <F : Number> two(p0: O, p1: I) = Unit
+        fun <F : Number> two(p0: O, p1: F) = Unit
+        fun <F : Number> two(p0: I, p1: O) = Unit
+        fun <F : Number> two(p0: I, p1: F) = Unit
+        fun <F : Number> two(p0: F, p1: O) = Unit
+        fun <F : Number> two(p0: F, p1: I) = Unit
+        fun <F : Number> three(p1: O, p2: I, p3: F) = Unit
+        fun <F : Number> three(p1: O, p2: F, p3: I) = Unit
+        fun <F : Number> three(p1: I, p2: O, p3: F) = Unit
+        fun <F : Number> three(p1: I, p2: F, p3: O) = Unit
+        fun <F : Number> three(p1: F, p2: O, p3: I) = Unit
+        fun <F : Number> three(p1: F, p2: I, p3: O) = Unit
+
+        inner class Inner2<I2 : StringBuilder>(p1: O, p2: I, p3: I2) {
+            inner class TypeParameterInSuperTypes : Interface<List<List<O>>, Map<I, I2>, Triple<O, I, I2>>
+
+            var I2.property: I2 get() = TODO()
+                set(_) = kotlin.Unit
+
+            fun <F : Number> four(p1: O, p2: I, p3: I2, p4: F) = Unit
+        }
+    }
+}

compiler/util-klib-abi/testData/content/type_parameters.v1.txt

@@ -0,0 +1,148 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testType_parameters>
+abstract interface <#A: kotlin/Any?, #B: kotlin/Any?, #C: kotlin/Any?> type_parameters.test/Interface // type_parameters.test/Interface|null[0]
+final class <#A: kotlin.text/Appendable> type_parameters.test/Outer { // type_parameters.test/Outer|null[0]
+    final var property // type_parameters.test/Outer.property|4489440291872326119[0]
+        final fun (#A).<get-property>(): #A // type_parameters.test/Outer.property.<get-property>|-6423108489323653642[0]
+        final fun (#A).<set-property>(#A) // type_parameters.test/Outer.property.<set-property>|-7713990379442476272[0]
+    final var property // type_parameters.test/Outer.property|3805809777609767839[0]
+        final fun <#A2: kotlin.collections/List<*>> (#A2).<get-property>(): #A2 // type_parameters.test/Outer.property.<get-property>|-822583820382794694[0]
+        final fun <#A2: kotlin.collections/List<*>> (#A2).<set-property>(#A2) // type_parameters.test/Outer.property.<set-property>|-4272932867940681381[0]
+    final var property // type_parameters.test/Outer.property|-1933538526084063185[0]
+        final fun <#A2: kotlin/Number> (#A2?).<get-property>(): #A2 // type_parameters.test/Outer.property.<get-property>|-6933461029252923757[0]
+        final fun <#A2: kotlin/Number> (#A2?).<set-property>(#A2) // type_parameters.test/Outer.property.<set-property>|2974327164734062311[0]
+    constructor <init>(#A) // type_parameters.test/Outer.<init>|-8731461708390519279[0]
+    final fun <#A1: kotlin/Number> one(#A1) // type_parameters.test/Outer.one|-7568257397933152931[0]
+    final fun one(#A) // type_parameters.test/Outer.one|1161222343553181190[0]
+    final fun <#A1: kotlin/Number> two(#A, #A1) // type_parameters.test/Outer.two|-341849875563176327[0]
+    final fun <#A1: kotlin/Number> two(#A1, #A) // type_parameters.test/Outer.two|-1944589062769169813[0]
+    final inner class <#A1: kotlin/CharSequence> Inner { // type_parameters.test/Outer.Inner|null[0]
+        final var property // type_parameters.test/Outer.Inner.property|-223347943824410311[0]
+            final fun (#A).<get-property>(): #A // type_parameters.test/Outer.Inner.property.<get-property>|-1243646438101729819[0]
+            final fun (#A).<set-property>(#A) // type_parameters.test/Outer.Inner.property.<set-property>|-8464632873940834829[0]
+        final var property // type_parameters.test/Outer.Inner.property|4489440291872326119[0]
+            final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Inner.property.<get-property>|-6423108489323653642[0]
+            final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Inner.property.<set-property>|-7713990379442476272[0]
+        final var property // type_parameters.test/Outer.Inner.property|3805809777609767839[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<get-property>(): #A3 // type_parameters.test/Outer.Inner.property.<get-property>|-822583820382794694[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<set-property>(#A3) // type_parameters.test/Outer.Inner.property.<set-property>|-4272932867940681381[0]
+        final var property // type_parameters.test/Outer.Inner.property|-1933538526084063185[0]
+            final fun <#A3: kotlin/Number> (#A3?).<get-property>(): #A3 // type_parameters.test/Outer.Inner.property.<get-property>|-6933461029252923757[0]
+            final fun <#A3: kotlin/Number> (#A3?).<set-property>(#A3) // type_parameters.test/Outer.Inner.property.<set-property>|2974327164734062311[0]
+        constructor <init>(#A, #A1) // type_parameters.test/Outer.Inner.<init>|-2512702059187080850[0]
+        final fun <#A2: kotlin/Number> one(#A2) // type_parameters.test/Outer.Inner.one|-7568257397933152931[0]
+        final fun one(#A) // type_parameters.test/Outer.Inner.one|-620981264376330367[0]
+        final fun one(#A1) // type_parameters.test/Outer.Inner.one|1161222343553181190[0]
+        final fun <#A2: kotlin/Number> three(#A, #A1, #A2) // type_parameters.test/Outer.Inner.three|-6822578316645026126[0]
+        final fun <#A2: kotlin/Number> three(#A, #A2, #A1) // type_parameters.test/Outer.Inner.three|-6068211090052702765[0]
+        final fun <#A2: kotlin/Number> three(#A1, #A, #A2) // type_parameters.test/Outer.Inner.three|2861877999510049331[0]
+        final fun <#A2: kotlin/Number> three(#A1, #A2, #A) // type_parameters.test/Outer.Inner.three|-3531545520938433496[0]
+        final fun <#A2: kotlin/Number> three(#A2, #A, #A1) // type_parameters.test/Outer.Inner.three|-973075002884847796[0]
+        final fun <#A2: kotlin/Number> three(#A2, #A1, #A) // type_parameters.test/Outer.Inner.three|-1778536435556039747[0]
+        final fun <#A2: kotlin/Number> two(#A, #A1) // type_parameters.test/Outer.Inner.two|8410250562024702156[0]
+        final fun <#A2: kotlin/Number> two(#A, #A2) // type_parameters.test/Outer.Inner.two|-5567322579908695124[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A) // type_parameters.test/Outer.Inner.two|-2477726922731367425[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Inner.two|-341849875563176327[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A) // type_parameters.test/Outer.Inner.two|989594013197241301[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Inner.two|-1944589062769169813[0]
+        final fun two(#A, #A1) // type_parameters.test/Outer.Inner.two|-1538715206688297331[0]
+        final fun two(#A1, #A) // type_parameters.test/Outer.Inner.two|2431719587830235698[0]
+        final inner class <#A2: kotlin.text/StringBuilder> Inner2 { // type_parameters.test/Outer.Inner.Inner2|null[0]
+            final var property // type_parameters.test/Outer.Inner.Inner2.property|4489440291872326119[0]
+                final fun (#A2).<get-property>(): #A2 // type_parameters.test/Outer.Inner.Inner2.property.<get-property>|-6423108489323653642[0]
+                final fun (#A2).<set-property>(#A2) // type_parameters.test/Outer.Inner.Inner2.property.<set-property>|-7713990379442476272[0]
+            constructor <init>(#A, #A1, #A2) // type_parameters.test/Outer.Inner.Inner2.<init>|7897092169597455163[0]
+            final fun <#A3: kotlin/Number> four(#A, #A1, #A2, #A3) // type_parameters.test/Outer.Inner.Inner2.four|-3752023088856709567[0]
+            final inner class TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#A1, #A2>, kotlin/Triple<#A, #A1, #A2>> { // type_parameters.test/Outer.Inner.Inner2.TypeParameterInSuperTypes|null[0]
+                constructor <init>() // type_parameters.test/Outer.Inner.Inner2.TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+            }
+        }
+        final inner class <#A2: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#A1, #A2>, kotlin/Triple<#A, #A1, #A2>> { // type_parameters.test/Outer.Inner.TypeParameterInSuperTypes|null[0]
+            constructor <init>() // type_parameters.test/Outer.Inner.TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+        }
+    }
+    final class <#A1: kotlin/CharSequence> Nested { // type_parameters.test/Outer.Nested|null[0]
+        final var property // type_parameters.test/Outer.Nested.property|4489440291872326119[0]
+            final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Nested.property.<get-property>|-6423108489323653642[0]
+            final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Nested.property.<set-property>|-7713990379442476272[0]
+        final var property // type_parameters.test/Outer.Nested.property|3805809777609767839[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<get-property>(): #A3 // type_parameters.test/Outer.Nested.property.<get-property>|-822583820382794694[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<set-property>(#A3) // type_parameters.test/Outer.Nested.property.<set-property>|-4272932867940681381[0]
+        final var property // type_parameters.test/Outer.Nested.property|-1933538526084063185[0]
+            final fun <#A3: kotlin/Number> (#A3?).<get-property>(): #A3 // type_parameters.test/Outer.Nested.property.<get-property>|-6933461029252923757[0]
+            final fun <#A3: kotlin/Number> (#A3?).<set-property>(#A3) // type_parameters.test/Outer.Nested.property.<set-property>|2974327164734062311[0]
+        constructor <init>(#A1) // type_parameters.test/Outer.Nested.<init>|-8731461708390519279[0]
+        final fun <#A2: kotlin/Number> one(#A2) // type_parameters.test/Outer.Nested.one|-7568257397933152931[0]
+        final fun one(#A1) // type_parameters.test/Outer.Nested.one|1161222343553181190[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Nested.two|-341849875563176327[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Nested.two|-1944589062769169813[0]
+        final inner class <#A2: kotlin.text/StringBuilder> Inner { // type_parameters.test/Outer.Nested.Inner|null[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|-223347943824410311[0]
+                final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|-1243646438101729819[0]
+                final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|-8464632873940834829[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|4489440291872326119[0]
+                final fun (#A2).<get-property>(): #A2 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|-6423108489323653642[0]
+                final fun (#A2).<set-property>(#A2) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|-7713990379442476272[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|3805809777609767839[0]
+                final fun <#A4: kotlin.collections/List<*>> (#A4).<get-property>(): #A4 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|-822583820382794694[0]
+                final fun <#A4: kotlin.collections/List<*>> (#A4).<set-property>(#A4) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|-4272932867940681381[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|-1933538526084063185[0]
+                final fun <#A4: kotlin/Number> (#A4?).<get-property>(): #A4 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|-6933461029252923757[0]
+                final fun <#A4: kotlin/Number> (#A4?).<set-property>(#A4) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|2974327164734062311[0]
+            constructor <init>(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.<init>|-2512702059187080850[0]
+            final fun <#A3: kotlin/Number> one(#A3) // type_parameters.test/Outer.Nested.Inner.one|-7568257397933152931[0]
+            final fun one(#A1) // type_parameters.test/Outer.Nested.Inner.one|-620981264376330367[0]
+            final fun one(#A2) // type_parameters.test/Outer.Nested.Inner.one|1161222343553181190[0]
+            final fun <#A3: kotlin/Number> three(#A1, #A2, #A3) // type_parameters.test/Outer.Nested.Inner.three|-6822578316645026126[0]
+            final fun <#A3: kotlin/Number> three(#A1, #A3, #A2) // type_parameters.test/Outer.Nested.Inner.three|-6068211090052702765[0]
+            final fun <#A3: kotlin/Number> three(#A2, #A1, #A3) // type_parameters.test/Outer.Nested.Inner.three|2861877999510049331[0]
+            final fun <#A3: kotlin/Number> three(#A2, #A3, #A1) // type_parameters.test/Outer.Nested.Inner.three|-3531545520938433496[0]
+            final fun <#A3: kotlin/Number> three(#A3, #A1, #A2) // type_parameters.test/Outer.Nested.Inner.three|-973075002884847796[0]
+            final fun <#A3: kotlin/Number> three(#A3, #A2, #A1) // type_parameters.test/Outer.Nested.Inner.three|-1778536435556039747[0]
+            final fun <#A3: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.two|8410250562024702156[0]
+            final fun <#A3: kotlin/Number> two(#A1, #A3) // type_parameters.test/Outer.Nested.Inner.two|-5567322579908695124[0]
+            final fun <#A3: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Nested.Inner.two|-2477726922731367425[0]
+            final fun <#A3: kotlin/Number> two(#A2, #A3) // type_parameters.test/Outer.Nested.Inner.two|-341849875563176327[0]
+            final fun <#A3: kotlin/Number> two(#A3, #A1) // type_parameters.test/Outer.Nested.Inner.two|989594013197241301[0]
+            final fun <#A3: kotlin/Number> two(#A3, #A2) // type_parameters.test/Outer.Nested.Inner.two|-1944589062769169813[0]
+            final fun two(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.two|-1538715206688297331[0]
+            final fun two(#A2, #A1) // type_parameters.test/Outer.Nested.Inner.two|2431719587830235698[0]
+            final inner class <#A3: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A1>>, kotlin.collections/Map<#A2, #A3>, kotlin/Triple<#A1, #A2, #A3>> { // type_parameters.test/Outer.Nested.Inner.TypeParameterInSuperTypes|null[0]
+                constructor <init>() // type_parameters.test/Outer.Nested.Inner.TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+            }
+        }
+        final inner class <#A2: kotlin/Any?, #B2: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A1>>, kotlin.collections/Map<#B2, #A2>, kotlin/Triple<#A1, #B2, #A2>> { // type_parameters.test/Outer.Nested.TypeParameterInSuperTypes|null[0]
+            constructor <init>() // type_parameters.test/Outer.Nested.TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+        }
+    }
+    final inner class <#A1: kotlin/Any?, #B1: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#B1, #A1>, kotlin/Triple<#A, #B1, #A1>> { // type_parameters.test/Outer.TypeParameterInSuperTypes|null[0]
+        constructor <init>() // type_parameters.test/Outer.TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+    }
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?, #C: kotlin/Any?> type_parameters.test/TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#C>>, kotlin.collections/Map<#B, #A>, kotlin/Triple<#C, #B, #A>> { // type_parameters.test/TypeParameterInSuperTypes|null[0]
+    constructor <init>() // type_parameters.test/TypeParameterInSuperTypes.<init>|-5645683436151566731[0]
+}
+final var type_parameters.test/property // type_parameters.test/property|2625757545133511549[0]
+    final fun <#A1: kotlin.collections/List<*>?> (#A1?).<get-property>(): #A1? // type_parameters.test/property.<get-property>|757188231170761296[0]
+    final fun <#A1: kotlin.collections/List<*>?> (#A1?).<set-property>(#A1?) // type_parameters.test/property.<set-property>|-596426223859746[0]
+final var type_parameters.test/property // type_parameters.test/property|-2650207999697234990[0]
+    final fun <#A1: kotlin.text/Appendable?> (#A1).<get-property>(): #A1 // type_parameters.test/property.<get-property>|2712377550872346404[0]
+    final fun <#A1: kotlin.text/Appendable?> (#A1).<set-property>(#A1) // type_parameters.test/property.<set-property>|-4350567656984308373[0]
+final var type_parameters.test/property // type_parameters.test/property|5046708877617142561[0]
+    final fun <#A1: kotlin/CharSequence> (#A1?).<get-property>(): #A1? // type_parameters.test/property.<get-property>|-8843539092800252583[0]
+    final fun <#A1: kotlin/CharSequence> (#A1?).<set-property>(#A1?) // type_parameters.test/property.<set-property>|-5766193361910944002[0]
+final var type_parameters.test/property // type_parameters.test/property|4472899887396146803[0]
+    final fun <#A1: kotlin/Number> (#A1).<get-property>(): #A1 // type_parameters.test/property.<get-property>|-6424239601896786367[0]
+    final fun <#A1: kotlin/Number> (#A1).<set-property>(#A1) // type_parameters.test/property.<set-property>|-6031856956419508218[0]
+final inline fun <#A: reified kotlin/Any?, #B: kotlin/Any?> type_parameters.test/functionWithReifiedParameter(#A, #B) // type_parameters.test/functionWithReifiedParameter|-4878473516716391225[0]
+final fun <#A: kotlin/CharSequence, #B: #A, #C: #B> type_parameters.test/interDependentTypeParameters(#A, #B, #C) // type_parameters.test/interDependentTypeParameters|6771956060301223135[0]
+final fun <#A: kotlin/Any?, #B: kotlin/Any, #C: kotlin/CharSequence?, #D: kotlin/CharSequence, #E: kotlin.text/Appendable?, #F: kotlin.text/Appendable, #G: kotlin/Number?, #H: kotlin/Number, #I: kotlin.collections/List<*>?, #J: kotlin.collections/List<*>, #K: kotlin/Any?, #L: kotlin/Any, #M: kotlin/CharSequence?, #N: kotlin/CharSequence, #O: kotlin.text/Appendable?, #P: kotlin.text/Appendable, #Q: kotlin/Number?, #R: kotlin/Number, #S: kotlin.collections/List<*>?, #T: kotlin.collections/List<*>, #U: kotlin/Any?, #V: kotlin/Any, #W: kotlin/CharSequence?, #X: kotlin/CharSequence, #Y: kotlin.text/Appendable?, #Z: kotlin.text/Appendable, #AA: kotlin/Number?, #AB: kotlin/Number, #AC: kotlin.collections/List<*>?, #AD: kotlin.collections/List<*>, #AE: kotlin/Any?, #AF: kotlin/Any, #AG: kotlin/CharSequence?, #AH: kotlin/CharSequence, #AI: kotlin.text/Appendable?, #AJ: kotlin.text/Appendable, #AK: kotlin/Number?, #AL: kotlin/Number, #AM: kotlin.collections/List<*>?, #AN: kotlin.collections/List<*>, #AO: kotlin/Any?, #AP: kotlin/Any, #AQ: kotlin/CharSequence?, #AR: kotlin/CharSequence, #AS: kotlin.text/Appendable?, #AT: kotlin.text/Appendable, #AU: kotlin/Number?, #AV: kotlin/Number, #AW: kotlin.collections/List<*>?, #AX: kotlin.collections/List<*>, #AY: kotlin/Any?, #AZ: kotlin/Any, #BA: kotlin/CharSequence?, #BB: kotlin/CharSequence, #BC: kotlin.text/Appendable?, #BD: kotlin.text/Appendable, #BE: kotlin/Number?, #BF: kotlin/Number, #BG: kotlin.collections/List<*>?, #BH: kotlin.collections/List<*>> type_parameters.test/lotsOfTypeParameters(): kotlin/CharSequence // type_parameters.test/lotsOfTypeParameters|8111178736292760853[0]
+final fun <#A: kotlin.text/Appendable & kotlin/CharSequence & kotlin/Number> type_parameters.test/multipleBounds(#A) // type_parameters.test/multipleBounds|-1381211984309993592[0]
+final fun <#A: kotlin.collections/List<*>?> type_parameters.test/one(#A?): #A? // type_parameters.test/one|-1125210795955507193[0]
+final fun <#A: kotlin.text/Appendable?> type_parameters.test/one(#A): #A // type_parameters.test/one|-468622467765550922[0]
+final fun <#A: kotlin/CharSequence> type_parameters.test/one(#A?): #A? // type_parameters.test/one|5100782278178255209[0]
+final fun <#A: kotlin/Number> type_parameters.test/one(#A): #A // type_parameters.test/one|-7568257397933152931[0]

compiler/util-klib-abi/testData/content/type_parameters.v2.txt

@@ -0,0 +1,148 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testType_parameters>
+abstract interface <#A: kotlin/Any?, #B: kotlin/Any?, #C: kotlin/Any?> type_parameters.test/Interface // type_parameters.test/Interface|null[0]
+final class <#A: kotlin.text/Appendable> type_parameters.test/Outer { // type_parameters.test/Outer|null[0]
+    final var property // type_parameters.test/Outer.property|@1:0{}property[0]
+        final fun (#A).<get-property>(): #A // type_parameters.test/Outer.property.<get-property>|<get-property>@1:0(){}[0]
+        final fun (#A).<set-property>(#A) // type_parameters.test/Outer.property.<set-property>|<set-property>@1:0(1:0){}[0]
+    final var property // type_parameters.test/Outer.property|@0:0{0§<kotlin.collections.List<*>>}property[0]
+        final fun <#A2: kotlin.collections/List<*>> (#A2).<get-property>(): #A2 // type_parameters.test/Outer.property.<get-property>|<get-property>@0:0(){0§<kotlin.collections.List<*>>}[0]
+        final fun <#A2: kotlin.collections/List<*>> (#A2).<set-property>(#A2) // type_parameters.test/Outer.property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.collections.List<*>>}[0]
+    final var property // type_parameters.test/Outer.property|@0:0?{0§<kotlin.Number>}property[0]
+        final fun <#A2: kotlin/Number> (#A2?).<get-property>(): #A2 // type_parameters.test/Outer.property.<get-property>|<get-property>@0:0?(){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> (#A2?).<set-property>(#A2) // type_parameters.test/Outer.property.<set-property>|<set-property>@0:0?(0:0){0§<kotlin.Number>}[0]
+    constructor <init>(#A) // type_parameters.test/Outer.<init>|<init>(1:0){}[0]
+    final fun <#A1: kotlin/Number> one(#A1) // type_parameters.test/Outer.one|one(0:0){0§<kotlin.Number>}[0]
+    final fun one(#A) // type_parameters.test/Outer.one|one(1:0){}[0]
+    final fun <#A1: kotlin/Number> two(#A, #A1) // type_parameters.test/Outer.two|two(1:0;0:0){0§<kotlin.Number>}[0]
+    final fun <#A1: kotlin/Number> two(#A1, #A) // type_parameters.test/Outer.two|two(0:0;1:0){0§<kotlin.Number>}[0]
+    final inner class <#A1: kotlin/CharSequence> Inner { // type_parameters.test/Outer.Inner|null[0]
+        final var property // type_parameters.test/Outer.Inner.property|@2:0{}property[0]
+            final fun (#A).<get-property>(): #A // type_parameters.test/Outer.Inner.property.<get-property>|<get-property>@2:0(){}[0]
+            final fun (#A).<set-property>(#A) // type_parameters.test/Outer.Inner.property.<set-property>|<set-property>@2:0(2:0){}[0]
+        final var property // type_parameters.test/Outer.Inner.property|@1:0{}property[0]
+            final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Inner.property.<get-property>|<get-property>@1:0(){}[0]
+            final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Inner.property.<set-property>|<set-property>@1:0(1:0){}[0]
+        final var property // type_parameters.test/Outer.Inner.property|@0:0{0§<kotlin.collections.List<*>>}property[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<get-property>(): #A3 // type_parameters.test/Outer.Inner.property.<get-property>|<get-property>@0:0(){0§<kotlin.collections.List<*>>}[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<set-property>(#A3) // type_parameters.test/Outer.Inner.property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.collections.List<*>>}[0]
+        final var property // type_parameters.test/Outer.Inner.property|@0:0?{0§<kotlin.Number>}property[0]
+            final fun <#A3: kotlin/Number> (#A3?).<get-property>(): #A3 // type_parameters.test/Outer.Inner.property.<get-property>|<get-property>@0:0?(){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> (#A3?).<set-property>(#A3) // type_parameters.test/Outer.Inner.property.<set-property>|<set-property>@0:0?(0:0){0§<kotlin.Number>}[0]
+        constructor <init>(#A, #A1) // type_parameters.test/Outer.Inner.<init>|<init>(2:0;1:0){}[0]
+        final fun <#A2: kotlin/Number> one(#A2) // type_parameters.test/Outer.Inner.one|one(0:0){0§<kotlin.Number>}[0]
+        final fun one(#A) // type_parameters.test/Outer.Inner.one|one(2:0){}[0]
+        final fun one(#A1) // type_parameters.test/Outer.Inner.one|one(1:0){}[0]
+        final fun <#A2: kotlin/Number> three(#A, #A1, #A2) // type_parameters.test/Outer.Inner.three|three(2:0;1:0;0:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> three(#A, #A2, #A1) // type_parameters.test/Outer.Inner.three|three(2:0;0:0;1:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> three(#A1, #A, #A2) // type_parameters.test/Outer.Inner.three|three(1:0;2:0;0:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> three(#A1, #A2, #A) // type_parameters.test/Outer.Inner.three|three(1:0;0:0;2:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> three(#A2, #A, #A1) // type_parameters.test/Outer.Inner.three|three(0:0;2:0;1:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> three(#A2, #A1, #A) // type_parameters.test/Outer.Inner.three|three(0:0;1:0;2:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A, #A1) // type_parameters.test/Outer.Inner.two|two(2:0;1:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A, #A2) // type_parameters.test/Outer.Inner.two|two(2:0;0:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A) // type_parameters.test/Outer.Inner.two|two(1:0;2:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Inner.two|two(1:0;0:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A) // type_parameters.test/Outer.Inner.two|two(0:0;2:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Inner.two|two(0:0;1:0){0§<kotlin.Number>}[0]
+        final fun two(#A, #A1) // type_parameters.test/Outer.Inner.two|two(2:0;1:0){}[0]
+        final fun two(#A1, #A) // type_parameters.test/Outer.Inner.two|two(1:0;2:0){}[0]
+        final inner class <#A2: kotlin.text/StringBuilder> Inner2 { // type_parameters.test/Outer.Inner.Inner2|null[0]
+            final var property // type_parameters.test/Outer.Inner.Inner2.property|@1:0{}property[0]
+                final fun (#A2).<get-property>(): #A2 // type_parameters.test/Outer.Inner.Inner2.property.<get-property>|<get-property>@1:0(){}[0]
+                final fun (#A2).<set-property>(#A2) // type_parameters.test/Outer.Inner.Inner2.property.<set-property>|<set-property>@1:0(1:0){}[0]
+            constructor <init>(#A, #A1, #A2) // type_parameters.test/Outer.Inner.Inner2.<init>|<init>(3:0;2:0;1:0){}[0]
+            final fun <#A3: kotlin/Number> four(#A, #A1, #A2, #A3) // type_parameters.test/Outer.Inner.Inner2.four|four(3:0;2:0;1:0;0:0){0§<kotlin.Number>}[0]
+            final inner class TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#A1, #A2>, kotlin/Triple<#A, #A1, #A2>> { // type_parameters.test/Outer.Inner.Inner2.TypeParameterInSuperTypes|null[0]
+                constructor <init>() // type_parameters.test/Outer.Inner.Inner2.TypeParameterInSuperTypes.<init>|<init>(){}[0]
+            }
+        }
+        final inner class <#A2: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#A1, #A2>, kotlin/Triple<#A, #A1, #A2>> { // type_parameters.test/Outer.Inner.TypeParameterInSuperTypes|null[0]
+            constructor <init>() // type_parameters.test/Outer.Inner.TypeParameterInSuperTypes.<init>|<init>(){}[0]
+        }
+    }
+    final class <#A1: kotlin/CharSequence> Nested { // type_parameters.test/Outer.Nested|null[0]
+        final var property // type_parameters.test/Outer.Nested.property|@1:0{}property[0]
+            final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Nested.property.<get-property>|<get-property>@1:0(){}[0]
+            final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Nested.property.<set-property>|<set-property>@1:0(1:0){}[0]
+        final var property // type_parameters.test/Outer.Nested.property|@0:0{0§<kotlin.collections.List<*>>}property[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<get-property>(): #A3 // type_parameters.test/Outer.Nested.property.<get-property>|<get-property>@0:0(){0§<kotlin.collections.List<*>>}[0]
+            final fun <#A3: kotlin.collections/List<*>> (#A3).<set-property>(#A3) // type_parameters.test/Outer.Nested.property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.collections.List<*>>}[0]
+        final var property // type_parameters.test/Outer.Nested.property|@0:0?{0§<kotlin.Number>}property[0]
+            final fun <#A3: kotlin/Number> (#A3?).<get-property>(): #A3 // type_parameters.test/Outer.Nested.property.<get-property>|<get-property>@0:0?(){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> (#A3?).<set-property>(#A3) // type_parameters.test/Outer.Nested.property.<set-property>|<set-property>@0:0?(0:0){0§<kotlin.Number>}[0]
+        constructor <init>(#A1) // type_parameters.test/Outer.Nested.<init>|<init>(1:0){}[0]
+        final fun <#A2: kotlin/Number> one(#A2) // type_parameters.test/Outer.Nested.one|one(0:0){0§<kotlin.Number>}[0]
+        final fun one(#A1) // type_parameters.test/Outer.Nested.one|one(1:0){}[0]
+        final fun <#A2: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Nested.two|two(1:0;0:0){0§<kotlin.Number>}[0]
+        final fun <#A2: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Nested.two|two(0:0;1:0){0§<kotlin.Number>}[0]
+        final inner class <#A2: kotlin.text/StringBuilder> Inner { // type_parameters.test/Outer.Nested.Inner|null[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|@2:0{}property[0]
+                final fun (#A1).<get-property>(): #A1 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|<get-property>@2:0(){}[0]
+                final fun (#A1).<set-property>(#A1) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|<set-property>@2:0(2:0){}[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|@1:0{}property[0]
+                final fun (#A2).<get-property>(): #A2 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|<get-property>@1:0(){}[0]
+                final fun (#A2).<set-property>(#A2) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|<set-property>@1:0(1:0){}[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|@0:0{0§<kotlin.collections.List<*>>}property[0]
+                final fun <#A4: kotlin.collections/List<*>> (#A4).<get-property>(): #A4 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|<get-property>@0:0(){0§<kotlin.collections.List<*>>}[0]
+                final fun <#A4: kotlin.collections/List<*>> (#A4).<set-property>(#A4) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.collections.List<*>>}[0]
+            final var property // type_parameters.test/Outer.Nested.Inner.property|@0:0?{0§<kotlin.Number>}property[0]
+                final fun <#A4: kotlin/Number> (#A4?).<get-property>(): #A4 // type_parameters.test/Outer.Nested.Inner.property.<get-property>|<get-property>@0:0?(){0§<kotlin.Number>}[0]
+                final fun <#A4: kotlin/Number> (#A4?).<set-property>(#A4) // type_parameters.test/Outer.Nested.Inner.property.<set-property>|<set-property>@0:0?(0:0){0§<kotlin.Number>}[0]
+            constructor <init>(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.<init>|<init>(2:0;1:0){}[0]
+            final fun <#A3: kotlin/Number> one(#A3) // type_parameters.test/Outer.Nested.Inner.one|one(0:0){0§<kotlin.Number>}[0]
+            final fun one(#A1) // type_parameters.test/Outer.Nested.Inner.one|one(2:0){}[0]
+            final fun one(#A2) // type_parameters.test/Outer.Nested.Inner.one|one(1:0){}[0]
+            final fun <#A3: kotlin/Number> three(#A1, #A2, #A3) // type_parameters.test/Outer.Nested.Inner.three|three(2:0;1:0;0:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> three(#A1, #A3, #A2) // type_parameters.test/Outer.Nested.Inner.three|three(2:0;0:0;1:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> three(#A2, #A1, #A3) // type_parameters.test/Outer.Nested.Inner.three|three(1:0;2:0;0:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> three(#A2, #A3, #A1) // type_parameters.test/Outer.Nested.Inner.three|three(1:0;0:0;2:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> three(#A3, #A1, #A2) // type_parameters.test/Outer.Nested.Inner.three|three(0:0;2:0;1:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> three(#A3, #A2, #A1) // type_parameters.test/Outer.Nested.Inner.three|three(0:0;1:0;2:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.two|two(2:0;1:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A1, #A3) // type_parameters.test/Outer.Nested.Inner.two|two(2:0;0:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A2, #A1) // type_parameters.test/Outer.Nested.Inner.two|two(1:0;2:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A2, #A3) // type_parameters.test/Outer.Nested.Inner.two|two(1:0;0:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A3, #A1) // type_parameters.test/Outer.Nested.Inner.two|two(0:0;2:0){0§<kotlin.Number>}[0]
+            final fun <#A3: kotlin/Number> two(#A3, #A2) // type_parameters.test/Outer.Nested.Inner.two|two(0:0;1:0){0§<kotlin.Number>}[0]
+            final fun two(#A1, #A2) // type_parameters.test/Outer.Nested.Inner.two|two(2:0;1:0){}[0]
+            final fun two(#A2, #A1) // type_parameters.test/Outer.Nested.Inner.two|two(1:0;2:0){}[0]
+            final inner class <#A3: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A1>>, kotlin.collections/Map<#A2, #A3>, kotlin/Triple<#A1, #A2, #A3>> { // type_parameters.test/Outer.Nested.Inner.TypeParameterInSuperTypes|null[0]
+                constructor <init>() // type_parameters.test/Outer.Nested.Inner.TypeParameterInSuperTypes.<init>|<init>(){}[0]
+            }
+        }
+        final inner class <#A2: kotlin/Any?, #B2: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A1>>, kotlin.collections/Map<#B2, #A2>, kotlin/Triple<#A1, #B2, #A2>> { // type_parameters.test/Outer.Nested.TypeParameterInSuperTypes|null[0]
+            constructor <init>() // type_parameters.test/Outer.Nested.TypeParameterInSuperTypes.<init>|<init>(){}[0]
+        }
+    }
+    final inner class <#A1: kotlin/Any?, #B1: kotlin/Any?> TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#A>>, kotlin.collections/Map<#B1, #A1>, kotlin/Triple<#A, #B1, #A1>> { // type_parameters.test/Outer.TypeParameterInSuperTypes|null[0]
+        constructor <init>() // type_parameters.test/Outer.TypeParameterInSuperTypes.<init>|<init>(){}[0]
+    }
+}
+final class <#A: kotlin/Any?, #B: kotlin/Any?, #C: kotlin/Any?> type_parameters.test/TypeParameterInSuperTypes : type_parameters.test/Interface<kotlin.collections/List<kotlin.collections/List<#C>>, kotlin.collections/Map<#B, #A>, kotlin/Triple<#C, #B, #A>> { // type_parameters.test/TypeParameterInSuperTypes|null[0]
+    constructor <init>() // type_parameters.test/TypeParameterInSuperTypes.<init>|<init>(){}[0]
+}
+final var type_parameters.test/property // type_parameters.test/property|@0:0?{0§<kotlin.collections.List<*>?>}property[0]
+    final fun <#A1: kotlin.collections/List<*>?> (#A1?).<get-property>(): #A1? // type_parameters.test/property.<get-property>|<get-property>@0:0?(){0§<kotlin.collections.List<*>?>}[0]
+    final fun <#A1: kotlin.collections/List<*>?> (#A1?).<set-property>(#A1?) // type_parameters.test/property.<set-property>|<set-property>@0:0?(0:0?){0§<kotlin.collections.List<*>?>}[0]
+final var type_parameters.test/property // type_parameters.test/property|@0:0{0§<kotlin.text.Appendable?>}property[0]
+    final fun <#A1: kotlin.text/Appendable?> (#A1).<get-property>(): #A1 // type_parameters.test/property.<get-property>|<get-property>@0:0(){0§<kotlin.text.Appendable?>}[0]
+    final fun <#A1: kotlin.text/Appendable?> (#A1).<set-property>(#A1) // type_parameters.test/property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.text.Appendable?>}[0]
+final var type_parameters.test/property // type_parameters.test/property|@0:0?{0§<kotlin.CharSequence>}property[0]
+    final fun <#A1: kotlin/CharSequence> (#A1?).<get-property>(): #A1? // type_parameters.test/property.<get-property>|<get-property>@0:0?(){0§<kotlin.CharSequence>}[0]
+    final fun <#A1: kotlin/CharSequence> (#A1?).<set-property>(#A1?) // type_parameters.test/property.<set-property>|<set-property>@0:0?(0:0?){0§<kotlin.CharSequence>}[0]
+final var type_parameters.test/property // type_parameters.test/property|@0:0{0§<kotlin.Number>}property[0]
+    final fun <#A1: kotlin/Number> (#A1).<get-property>(): #A1 // type_parameters.test/property.<get-property>|<get-property>@0:0(){0§<kotlin.Number>}[0]
+    final fun <#A1: kotlin/Number> (#A1).<set-property>(#A1) // type_parameters.test/property.<set-property>|<set-property>@0:0(0:0){0§<kotlin.Number>}[0]
+final inline fun <#A: reified kotlin/Any?, #B: kotlin/Any?> type_parameters.test/functionWithReifiedParameter(#A, #B) // type_parameters.test/functionWithReifiedParameter|functionWithReifiedParameter(0:0;0:1){0§<kotlin.Any?>;1§<kotlin.Any?>}[0]
+final fun <#A: kotlin/CharSequence, #B: #A, #C: #B> type_parameters.test/interDependentTypeParameters(#A, #B, #C) // type_parameters.test/interDependentTypeParameters|interDependentTypeParameters(0:0;0:1;0:2){0§<kotlin.CharSequence>;1§<0:0>;2§<0:1>}[0]
+final fun <#A: kotlin/Any?, #B: kotlin/Any, #C: kotlin/CharSequence?, #D: kotlin/CharSequence, #E: kotlin.text/Appendable?, #F: kotlin.text/Appendable, #G: kotlin/Number?, #H: kotlin/Number, #I: kotlin.collections/List<*>?, #J: kotlin.collections/List<*>, #K: kotlin/Any?, #L: kotlin/Any, #M: kotlin/CharSequence?, #N: kotlin/CharSequence, #O: kotlin.text/Appendable?, #P: kotlin.text/Appendable, #Q: kotlin/Number?, #R: kotlin/Number, #S: kotlin.collections/List<*>?, #T: kotlin.collections/List<*>, #U: kotlin/Any?, #V: kotlin/Any, #W: kotlin/CharSequence?, #X: kotlin/CharSequence, #Y: kotlin.text/Appendable?, #Z: kotlin.text/Appendable, #AA: kotlin/Number?, #AB: kotlin/Number, #AC: kotlin.collections/List<*>?, #AD: kotlin.collections/List<*>, #AE: kotlin/Any?, #AF: kotlin/Any, #AG: kotlin/CharSequence?, #AH: kotlin/CharSequence, #AI: kotlin.text/Appendable?, #AJ: kotlin.text/Appendable, #AK: kotlin/Number?, #AL: kotlin/Number, #AM: kotlin.collections/List<*>?, #AN: kotlin.collections/List<*>, #AO: kotlin/Any?, #AP: kotlin/Any, #AQ: kotlin/CharSequence?, #AR: kotlin/CharSequence, #AS: kotlin.text/Appendable?, #AT: kotlin.text/Appendable, #AU: kotlin/Number?, #AV: kotlin/Number, #AW: kotlin.collections/List<*>?, #AX: kotlin.collections/List<*>, #AY: kotlin/Any?, #AZ: kotlin/Any, #BA: kotlin/CharSequence?, #BB: kotlin/CharSequence, #BC: kotlin.text/Appendable?, #BD: kotlin.text/Appendable, #BE: kotlin/Number?, #BF: kotlin/Number, #BG: kotlin.collections/List<*>?, #BH: kotlin.collections/List<*>> type_parameters.test/lotsOfTypeParameters(): kotlin/CharSequence // type_parameters.test/lotsOfTypeParameters|lotsOfTypeParameters(){0§<kotlin.Any?>;1§<kotlin.Any>;2§<kotlin.CharSequence?>;3§<kotlin.CharSequence>;4§<kotlin.text.Appendable?>;5§<kotlin.text.Appendable>;6§<kotlin.Number?>;7§<kotlin.Number>;8§<kotlin.collections.List<*>?>;9§<kotlin.collections.List<*>>;10§<kotlin.Any?>;11§<kotlin.Any>;12§<kotlin.CharSequence?>;13§<kotlin.CharSequence>;14§<kotlin.text.Appendable?>;15§<kotlin.text.Appendable>;16§<kotlin.Number?>;17§<kotlin.Number>;18§<kotlin.collections.List<*>?>;19§<kotlin.collections.List<*>>;20§<kotlin.Any?>;21§<kotlin.Any>;22§<kotlin.CharSequence?>;23§<kotlin.CharSequence>;24§<kotlin.text.Appendable?>;25§<kotlin.text.Appendable>;26§<kotlin.Number?>;27§<kotlin.Number>;28§<kotlin.collections.List<*>?>;29§<kotlin.collections.List<*>>;30§<kotlin.Any?>;31§<kotlin.Any>;32§<kotlin.CharSequence?>;33§<kotlin.CharSequence>;34§<kotlin.text.Appendable?>;35§<kotlin.text.Appendable>;36§<kotlin.Number?>;37§<kotlin.Number>;38§<kotlin.collections.List<*>?>;39§<kotlin.collections.List<*>>;40§<kotlin.Any?>;41§<kotlin.Any>;42§<kotlin.CharSequence?>;43§<kotlin.CharSequence>;44§<kotlin.text.Appendable?>;45§<kotlin.text.Appendable>;46§<kotlin.Number?>;47§<kotlin.Number>;48§<kotlin.collections.List<*>?>;49§<kotlin.collections.List<*>>;50§<kotlin.Any?>;51§<kotlin.Any>;52§<kotlin.CharSequence?>;53§<kotlin.CharSequence>;54§<kotlin.text.Appendable?>;55§<kotlin.text.Appendable>;56§<kotlin.Number?>;57§<kotlin.Number>;58§<kotlin.collections.List<*>?>;59§<kotlin.collections.List<*>>}[0]
+final fun <#A: kotlin.text/Appendable & kotlin/CharSequence & kotlin/Number> type_parameters.test/multipleBounds(#A) // type_parameters.test/multipleBounds|multipleBounds(0:0){0§<kotlin.CharSequence&kotlin.text.Appendable&kotlin.Number>}[0]
+final fun <#A: kotlin.collections/List<*>?> type_parameters.test/one(#A?): #A? // type_parameters.test/one|one(0:0?){0§<kotlin.collections.List<*>?>}[0]
+final fun <#A: kotlin.text/Appendable?> type_parameters.test/one(#A): #A // type_parameters.test/one|one(0:0){0§<kotlin.text.Appendable?>}[0]
+final fun <#A: kotlin/CharSequence> type_parameters.test/one(#A?): #A? // type_parameters.test/one|one(0:0?){0§<kotlin.CharSequence>}[0]
+final fun <#A: kotlin/Number> type_parameters.test/one(#A): #A // type_parameters.test/one|one(0:0){0§<kotlin.Number>}[0]

compiler/util-klib-abi/testData/content/value_parameters.kt

@@ -0,0 +1,25 @@
+package value_parameters.test
+
+inline fun funWithInlineParameters1(
+    inlineBlock: (Int) -> String,
+    noinline noinlineBlock: (Int) -> String,
+    crossinline crossinlineBlock: (Int) -> String
+): String = ""
+
+inline fun funWithInlineParameters2(
+    inlineBlock: Function1<Int, String>,
+    noinline noinlineBlock: Function1<Int, String>,
+    crossinline crossinlineBlock: Function1<Int, String>
+): String = ""
+
+fun funWithDefaultArgs(p1: Int = 42, p2: Long, p3: String = ""): String = ""
+fun funWithVararg(vararg p: Any?): String = ""
+fun funWithVarargAndDefaultArg(vararg p: Long = longArrayOf(1L, 2L, 3L)): String = p.joinToString()
+fun funWithVarargAndDefaultArg(vararg p: Any? = arrayOf("hello", 2, null)): String = p.joinToString()
+
+// This is needed to check that value parameter indices are properly deserialized for functions with context receivers.
+context(Int, Long) fun funWithDefaultArgs(p1: Int = 42, p2: Long, p3: String = ""): String = ""
+
+inline fun funWithMixedStuff(
+    crossinline block: (Int) -> String = { it.toString() }
+): String = ""

compiler/util-klib-abi/testData/content/value_parameters.v1.txt

@@ -0,0 +1,14 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testValue_parameters>
+final fun value_parameters.test/funWithDefaultArgs(kotlin/Int =..., kotlin/Long, kotlin/String =...): kotlin/String // value_parameters.test/funWithDefaultArgs|-2013334893880470152[0]
+final fun context(kotlin/Int, kotlin/Long) value_parameters.test/funWithDefaultArgs(kotlin/Int =..., kotlin/Long, kotlin/String =...): kotlin/String // value_parameters.test/funWithDefaultArgs|-1283395221811731897[0]
+final inline fun value_parameters.test/funWithInlineParameters1(kotlin/Function1<kotlin/Int, kotlin/String>, noinline kotlin/Function1<kotlin/Int, kotlin/String>, crossinline kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // value_parameters.test/funWithInlineParameters1|8789385144825475619[0]
+final inline fun value_parameters.test/funWithInlineParameters2(kotlin/Function1<kotlin/Int, kotlin/String>, noinline kotlin/Function1<kotlin/Int, kotlin/String>, crossinline kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // value_parameters.test/funWithInlineParameters2|-8517782923091139351[0]
+final inline fun value_parameters.test/funWithMixedStuff(crossinline kotlin/Function1<kotlin/Int, kotlin/String> =...): kotlin/String // value_parameters.test/funWithMixedStuff|6465248722251168090[0]
+final fun value_parameters.test/funWithVararg(kotlin/Array<out kotlin/Any?>...): kotlin/String // value_parameters.test/funWithVararg|-6768739871601372622[0]
+final fun value_parameters.test/funWithVarargAndDefaultArg(kotlin/Array<out kotlin/Any?>... =...): kotlin/String // value_parameters.test/funWithVarargAndDefaultArg|8916237708127614843[0]
+final fun value_parameters.test/funWithVarargAndDefaultArg(kotlin/LongArray... =...): kotlin/String // value_parameters.test/funWithVarargAndDefaultArg|7273069930119485025[0]

compiler/util-klib-abi/testData/content/value_parameters.v2.txt

@@ -0,0 +1,14 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testValue_parameters>
+final fun value_parameters.test/funWithDefaultArgs(kotlin/Int =..., kotlin/Long, kotlin/String =...): kotlin/String // value_parameters.test/funWithDefaultArgs|funWithDefaultArgs(kotlin.Int;kotlin.Long;kotlin.String){}[0]
+final fun context(kotlin/Int, kotlin/Long) value_parameters.test/funWithDefaultArgs(kotlin/Int =..., kotlin/Long, kotlin/String =...): kotlin/String // value_parameters.test/funWithDefaultArgs|funWithDefaultArgs!kotlin.Int!kotlin.Long(kotlin.Int;kotlin.Long;kotlin.String){}[0]
+final inline fun value_parameters.test/funWithInlineParameters1(kotlin/Function1<kotlin/Int, kotlin/String>, noinline kotlin/Function1<kotlin/Int, kotlin/String>, crossinline kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // value_parameters.test/funWithInlineParameters1|funWithInlineParameters1(kotlin.Function1<kotlin.Int,kotlin.String>;kotlin.Function1<kotlin.Int,kotlin.String>;kotlin.Function1<kotlin.Int,kotlin.String>){}[0]
+final inline fun value_parameters.test/funWithInlineParameters2(kotlin/Function1<kotlin/Int, kotlin/String>, noinline kotlin/Function1<kotlin/Int, kotlin/String>, crossinline kotlin/Function1<kotlin/Int, kotlin/String>): kotlin/String // value_parameters.test/funWithInlineParameters2|funWithInlineParameters2(kotlin.Function1<kotlin.Int,kotlin.String>;kotlin.Function1<kotlin.Int,kotlin.String>;kotlin.Function1<kotlin.Int,kotlin.String>){}[0]
+final inline fun value_parameters.test/funWithMixedStuff(crossinline kotlin/Function1<kotlin/Int, kotlin/String> =...): kotlin/String // value_parameters.test/funWithMixedStuff|funWithMixedStuff(kotlin.Function1<kotlin.Int,kotlin.String>){}[0]
+final fun value_parameters.test/funWithVararg(kotlin/Array<out kotlin/Any?>...): kotlin/String // value_parameters.test/funWithVararg|funWithVararg(kotlin.Array<out|kotlin.Any?>...){}[0]
+final fun value_parameters.test/funWithVarargAndDefaultArg(kotlin/Array<out kotlin/Any?>... =...): kotlin/String // value_parameters.test/funWithVarargAndDefaultArg|funWithVarargAndDefaultArg(kotlin.Array<out|kotlin.Any?>...){}[0]
+final fun value_parameters.test/funWithVarargAndDefaultArg(kotlin/LongArray... =...): kotlin/String // value_parameters.test/funWithVarargAndDefaultArg|funWithVarargAndDefaultArg(kotlin.LongArray...){}[0]

compiler/util-klib-abi/testData/content/visibilities.kt

@@ -0,0 +1,73 @@
+package visibilities.test
+
+public fun publicFun(): String = ""
+internal fun internalFun(): String = ""
+@PublishedApi internal fun internalPAFun(): String = ""
+private fun privateFun(): String = ""
+
+public val publicVal: String get() = ""
+internal val internalVal: String get() = ""
+@PublishedApi internal val internalPAVal: String get() = ""
+private val privateVal: String get() = ""
+
+public var publicVarPublicSetter: String get() = ""
+    set(_) = Unit
+public var publicVarInternalSetter: String get() = ""
+    internal set(_) = Unit
+public var publicVarPrivateSetter: String get() = ""
+    private set(_) = Unit
+internal var internalVar: String get() = ""
+    set(_) = Unit
+@PublishedApi internal var internalPAVarInternalSetter: String get() = ""
+    set(_) = Unit
+@PublishedApi internal var internalPAVarPrivateSetter: String get() = ""
+    private set(_) = Unit
+
+public class PublicClass(val property: String) {
+    fun function(): String = ""
+    class NestedClass
+}
+public class PublicClassProtectedMembers protected constructor(protected val property: String) {
+    protected fun function(): String = ""
+    protected class NestedClass
+}
+public abstract class PublicAbstractClassProtectedMembers protected constructor(protected val property: String) {
+    protected fun function(): String = ""
+    protected class NestedClass
+}
+public open class PublicOpenClassProtectedMembers protected constructor(protected val property: String) {
+    protected fun function(): String = ""
+    protected class NestedClass
+}
+public class PublicClassInternalMembers internal constructor(internal val property: String) {
+    internal fun function(): String = ""
+    internal class NestedClass
+}
+public class PublicClassInternalPAMembers @PublishedApi internal constructor(@PublishedApi internal val property: String) {
+    @PublishedApi internal fun function(): String = ""
+    @PublishedApi internal class NestedClass
+}
+public class PublicClassPrivateMembers private constructor(private val property: String) {
+    private fun function(): String = ""
+    private class NestedClass
+}
+internal class InternalClass(val property: String) {
+    fun function(): String = ""
+    class NestedClass
+}
+@PublishedApi internal class InternalPAClass(val property: String) {
+    fun function(): String = ""
+    class NestedClass
+}
+@PublishedApi internal class InternalPAClassInternalMembers internal constructor(internal val property: String) {
+    internal fun function(): String = ""
+    internal class NestedClass
+}
+@PublishedApi internal class InternalPAClassInternalPAMembers @PublishedApi internal constructor(@PublishedApi internal val property: String) {
+    @PublishedApi internal fun function(): String = ""
+    @PublishedApi internal class NestedClass
+}
+private class PrivateClass(val property: String) {
+    fun function(): String = ""
+    class NestedClass
+}

compiler/util-klib-abi/testData/content/visibilities.v1.txt

@@ -0,0 +1,82 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testVisibilities>
+final class visibilities.test/InternalPAClass { // visibilities.test/InternalPAClass|null[0]
+    final val property // visibilities.test/InternalPAClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/InternalPAClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/InternalPAClass.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/InternalPAClass.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/InternalPAClass.NestedClass|null[0]
+        constructor <init>() // visibilities.test/InternalPAClass.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+final class visibilities.test/InternalPAClassInternalMembers // visibilities.test/InternalPAClassInternalMembers|null[0]
+final class visibilities.test/InternalPAClassInternalPAMembers { // visibilities.test/InternalPAClassInternalPAMembers|null[0]
+    final val property // visibilities.test/InternalPAClassInternalPAMembers.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/InternalPAClassInternalPAMembers.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/InternalPAClassInternalPAMembers.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/InternalPAClassInternalPAMembers.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/InternalPAClassInternalPAMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/InternalPAClassInternalPAMembers.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+abstract class visibilities.test/PublicAbstractClassProtectedMembers { // visibilities.test/PublicAbstractClassProtectedMembers|null[0]
+    final val property // visibilities.test/PublicAbstractClassProtectedMembers.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicAbstractClassProtectedMembers.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicAbstractClassProtectedMembers.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/PublicAbstractClassProtectedMembers.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/PublicAbstractClassProtectedMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicAbstractClassProtectedMembers.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+final class visibilities.test/PublicClass { // visibilities.test/PublicClass|null[0]
+    final val property // visibilities.test/PublicClass.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicClass.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicClass.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/PublicClass.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/PublicClass.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicClass.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+final class visibilities.test/PublicClassInternalMembers // visibilities.test/PublicClassInternalMembers|null[0]
+final class visibilities.test/PublicClassInternalPAMembers { // visibilities.test/PublicClassInternalPAMembers|null[0]
+    final val property // visibilities.test/PublicClassInternalPAMembers.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicClassInternalPAMembers.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicClassInternalPAMembers.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/PublicClassInternalPAMembers.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/PublicClassInternalPAMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicClassInternalPAMembers.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+final class visibilities.test/PublicClassPrivateMembers // visibilities.test/PublicClassPrivateMembers|null[0]
+final class visibilities.test/PublicClassProtectedMembers // visibilities.test/PublicClassProtectedMembers|null[0]
+open class visibilities.test/PublicOpenClassProtectedMembers { // visibilities.test/PublicOpenClassProtectedMembers|null[0]
+    final val property // visibilities.test/PublicOpenClassProtectedMembers.property|4634558160746314112[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicOpenClassProtectedMembers.property.<get-property>|4838831487146901942[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicOpenClassProtectedMembers.<init>|1280618353163213788[0]
+    final fun function(): kotlin/String // visibilities.test/PublicOpenClassProtectedMembers.function|-3322893411126713785[0]
+    final class NestedClass { // visibilities.test/PublicOpenClassProtectedMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicOpenClassProtectedMembers.NestedClass.<init>|-5645683436151566731[0]
+    }
+}
+final val visibilities.test/internalPAVal // visibilities.test/internalPAVal|-6296713716360945427[0]
+    final fun <get-internalPAVal>(): kotlin/String // visibilities.test/internalPAVal.<get-internalPAVal>|-2220884681594955448[0]
+final var visibilities.test/internalPAVarInternalSetter // visibilities.test/internalPAVarInternalSetter|8606185858874286601[0]
+    final fun <get-internalPAVarInternalSetter>(): kotlin/String // visibilities.test/internalPAVarInternalSetter.<get-internalPAVarInternalSetter>|-2165138686967166236[0]
+    final fun <set-internalPAVarInternalSetter>(kotlin/String) // visibilities.test/internalPAVarInternalSetter.<set-internalPAVarInternalSetter>|4268094736790597293[0]
+final var visibilities.test/internalPAVarPrivateSetter // visibilities.test/internalPAVarPrivateSetter|5404459463495216914[0]
+    final fun <get-internalPAVarPrivateSetter>(): kotlin/String // visibilities.test/internalPAVarPrivateSetter.<get-internalPAVarPrivateSetter>|7858377503331561427[0]
+final val visibilities.test/publicVal // visibilities.test/publicVal|7143563926198876043[0]
+    final fun <get-publicVal>(): kotlin/String // visibilities.test/publicVal.<get-publicVal>|1629535235632860507[0]
+final var visibilities.test/publicVarInternalSetter // visibilities.test/publicVarInternalSetter|-2855768891968336973[0]
+    final fun <get-publicVarInternalSetter>(): kotlin/String // visibilities.test/publicVarInternalSetter.<get-publicVarInternalSetter>|-5725447636241167149[0]
+final var visibilities.test/publicVarPrivateSetter // visibilities.test/publicVarPrivateSetter|8666989530943431000[0]
+    final fun <get-publicVarPrivateSetter>(): kotlin/String // visibilities.test/publicVarPrivateSetter.<get-publicVarPrivateSetter>|4875313296516845411[0]
+final var visibilities.test/publicVarPublicSetter // visibilities.test/publicVarPublicSetter|2172609198358158808[0]
+    final fun <get-publicVarPublicSetter>(): kotlin/String // visibilities.test/publicVarPublicSetter.<get-publicVarPublicSetter>|3106038528912026803[0]
+    final fun <set-publicVarPublicSetter>(kotlin/String) // visibilities.test/publicVarPublicSetter.<set-publicVarPublicSetter>|7158661382309278782[0]
+final fun visibilities.test/internalPAFun(): kotlin/String // visibilities.test/internalPAFun|6209200454159161588[0]
+final fun visibilities.test/publicFun(): kotlin/String // visibilities.test/publicFun|-6665644650067461598[0]

compiler/util-klib-abi/testData/content/visibilities.v2.txt

@@ -0,0 +1,82 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testVisibilities>
+final class visibilities.test/InternalPAClass { // visibilities.test/InternalPAClass|null[0]
+    final val property // visibilities.test/InternalPAClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/InternalPAClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/InternalPAClass.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/InternalPAClass.function|function(){}[0]
+    final class NestedClass { // visibilities.test/InternalPAClass.NestedClass|null[0]
+        constructor <init>() // visibilities.test/InternalPAClass.NestedClass.<init>|<init>(){}[0]
+    }
+}
+final class visibilities.test/InternalPAClassInternalMembers // visibilities.test/InternalPAClassInternalMembers|null[0]
+final class visibilities.test/InternalPAClassInternalPAMembers { // visibilities.test/InternalPAClassInternalPAMembers|null[0]
+    final val property // visibilities.test/InternalPAClassInternalPAMembers.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/InternalPAClassInternalPAMembers.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/InternalPAClassInternalPAMembers.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/InternalPAClassInternalPAMembers.function|function(){}[0]
+    final class NestedClass { // visibilities.test/InternalPAClassInternalPAMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/InternalPAClassInternalPAMembers.NestedClass.<init>|<init>(){}[0]
+    }
+}
+abstract class visibilities.test/PublicAbstractClassProtectedMembers { // visibilities.test/PublicAbstractClassProtectedMembers|null[0]
+    final val property // visibilities.test/PublicAbstractClassProtectedMembers.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicAbstractClassProtectedMembers.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicAbstractClassProtectedMembers.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/PublicAbstractClassProtectedMembers.function|function(){}[0]
+    final class NestedClass { // visibilities.test/PublicAbstractClassProtectedMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicAbstractClassProtectedMembers.NestedClass.<init>|<init>(){}[0]
+    }
+}
+final class visibilities.test/PublicClass { // visibilities.test/PublicClass|null[0]
+    final val property // visibilities.test/PublicClass.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicClass.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicClass.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/PublicClass.function|function(){}[0]
+    final class NestedClass { // visibilities.test/PublicClass.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicClass.NestedClass.<init>|<init>(){}[0]
+    }
+}
+final class visibilities.test/PublicClassInternalMembers // visibilities.test/PublicClassInternalMembers|null[0]
+final class visibilities.test/PublicClassInternalPAMembers { // visibilities.test/PublicClassInternalPAMembers|null[0]
+    final val property // visibilities.test/PublicClassInternalPAMembers.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicClassInternalPAMembers.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicClassInternalPAMembers.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/PublicClassInternalPAMembers.function|function(){}[0]
+    final class NestedClass { // visibilities.test/PublicClassInternalPAMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicClassInternalPAMembers.NestedClass.<init>|<init>(){}[0]
+    }
+}
+final class visibilities.test/PublicClassPrivateMembers // visibilities.test/PublicClassPrivateMembers|null[0]
+final class visibilities.test/PublicClassProtectedMembers // visibilities.test/PublicClassProtectedMembers|null[0]
+open class visibilities.test/PublicOpenClassProtectedMembers { // visibilities.test/PublicOpenClassProtectedMembers|null[0]
+    final val property // visibilities.test/PublicOpenClassProtectedMembers.property|{}property[0]
+        final fun <get-property>(): kotlin/String // visibilities.test/PublicOpenClassProtectedMembers.property.<get-property>|<get-property>(){}[0]
+    constructor <init>(kotlin/String) // visibilities.test/PublicOpenClassProtectedMembers.<init>|<init>(kotlin.String){}[0]
+    final fun function(): kotlin/String // visibilities.test/PublicOpenClassProtectedMembers.function|function(){}[0]
+    final class NestedClass { // visibilities.test/PublicOpenClassProtectedMembers.NestedClass|null[0]
+        constructor <init>() // visibilities.test/PublicOpenClassProtectedMembers.NestedClass.<init>|<init>(){}[0]
+    }
+}
+final val visibilities.test/internalPAVal // visibilities.test/internalPAVal|{}internalPAVal[0]
+    final fun <get-internalPAVal>(): kotlin/String // visibilities.test/internalPAVal.<get-internalPAVal>|<get-internalPAVal>(){}[0]
+final var visibilities.test/internalPAVarInternalSetter // visibilities.test/internalPAVarInternalSetter|{}internalPAVarInternalSetter[0]
+    final fun <get-internalPAVarInternalSetter>(): kotlin/String // visibilities.test/internalPAVarInternalSetter.<get-internalPAVarInternalSetter>|<get-internalPAVarInternalSetter>(){}[0]
+    final fun <set-internalPAVarInternalSetter>(kotlin/String) // visibilities.test/internalPAVarInternalSetter.<set-internalPAVarInternalSetter>|<set-internalPAVarInternalSetter>(kotlin.String){}[0]
+final var visibilities.test/internalPAVarPrivateSetter // visibilities.test/internalPAVarPrivateSetter|{}internalPAVarPrivateSetter[0]
+    final fun <get-internalPAVarPrivateSetter>(): kotlin/String // visibilities.test/internalPAVarPrivateSetter.<get-internalPAVarPrivateSetter>|<get-internalPAVarPrivateSetter>(){}[0]
+final val visibilities.test/publicVal // visibilities.test/publicVal|{}publicVal[0]
+    final fun <get-publicVal>(): kotlin/String // visibilities.test/publicVal.<get-publicVal>|<get-publicVal>(){}[0]
+final var visibilities.test/publicVarInternalSetter // visibilities.test/publicVarInternalSetter|{}publicVarInternalSetter[0]
+    final fun <get-publicVarInternalSetter>(): kotlin/String // visibilities.test/publicVarInternalSetter.<get-publicVarInternalSetter>|<get-publicVarInternalSetter>(){}[0]
+final var visibilities.test/publicVarPrivateSetter // visibilities.test/publicVarPrivateSetter|{}publicVarPrivateSetter[0]
+    final fun <get-publicVarPrivateSetter>(): kotlin/String // visibilities.test/publicVarPrivateSetter.<get-publicVarPrivateSetter>|<get-publicVarPrivateSetter>(){}[0]
+final var visibilities.test/publicVarPublicSetter // visibilities.test/publicVarPublicSetter|{}publicVarPublicSetter[0]
+    final fun <get-publicVarPublicSetter>(): kotlin/String // visibilities.test/publicVarPublicSetter.<get-publicVarPublicSetter>|<get-publicVarPublicSetter>(){}[0]
+    final fun <set-publicVarPublicSetter>(kotlin/String) // visibilities.test/publicVarPublicSetter.<set-publicVarPublicSetter>|<set-publicVarPublicSetter>(kotlin.String){}[0]
+final fun visibilities.test/internalPAFun(): kotlin/String // visibilities.test/internalPAFun|internalPAFun(){}[0]
+final fun visibilities.test/publicFun(): kotlin/String // visibilities.test/publicFun|publicFun(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_1.kt

@@ -0,0 +1,116 @@
+// NON_PUBLIC_MARKERS: one.two/Three.Four five.six/Seven.Eight nine.ten/Eleven.Twelve
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_1.v1.txt

@@ -0,0 +1,241 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_1>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|-5645683436151566731[0]
+}
+final class /ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithFoo { // /ClassMarkedWithFoo|null[0]
+    constructor <init>() // /ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar { // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithFoo { // /ClassWithConstructorMarkedWithFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithFoo.<init>|-5645683436151566731[0]
+}
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|-5645683436151566731[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // /NonMarkedClass.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // /propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|7768138341638919361[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <get-propertyGetterMarkedWithFoo>(): kotlin/String // /propertyGetterMarkedWithFoo.<get-propertyGetterMarkedWithFoo>|7715429316947815497[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // /propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|7757487364805814175[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+    final fun <set-propertySetterMarkedWithFoo>(kotlin/String) // /propertySetterMarkedWithFoo.<set-propertySetterMarkedWithFoo>|-5398085748280780705[0]
+final var /propertyWholeMarkedWithAnotherBar // /propertyWholeMarkedWithAnotherBar|9162962495777663780[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // /propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|-1161906039333473922[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // /propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|-4350706110481715922[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final var /propertyWholeMarkedWithFoo // /propertyWholeMarkedWithFoo|1235853922868560214[0]
+    final fun <get-propertyWholeMarkedWithFoo>(): kotlin/String // /propertyWholeMarkedWithFoo.<get-propertyWholeMarkedWithFoo>|-8118247767275252666[0]
+    final fun <set-propertyWholeMarkedWithFoo>(kotlin/String) // /propertyWholeMarkedWithFoo.<set-propertyWholeMarkedWithFoo>|1985764616902292422[0]
+final fun /functionMarkedWithAnotherBar(): kotlin/String // /functionMarkedWithAnotherBar|-2313438891947829111[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|-4713248467320396269[0]
+final fun /functionMarkedWithFoo(): kotlin/String // /functionMarkedWithFoo|5454702469127665692[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_1.v2.txt

@@ -0,0 +1,241 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_1>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|<init>(){}[0]
+}
+final class /ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithFoo { // /ClassMarkedWithFoo|null[0]
+    constructor <init>() // /ClassMarkedWithFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // /ClassMarkedWithFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar { // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherBar.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithFoo { // /ClassWithConstructorMarkedWithFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithFoo.<init>|<init>(){}[0]
+}
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|<init>(){}[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // /NonMarkedClass.ClassMarkedWithFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // /propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|<get-propertyGetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <get-propertyGetterMarkedWithFoo>(): kotlin/String // /propertyGetterMarkedWithFoo.<get-propertyGetterMarkedWithFoo>|<get-propertyGetterMarkedWithFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // /propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|<set-propertySetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithFoo>(kotlin/String) // /propertySetterMarkedWithFoo.<set-propertySetterMarkedWithFoo>|<set-propertySetterMarkedWithFoo>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithAnotherBar // /propertyWholeMarkedWithAnotherBar|{}propertyWholeMarkedWithAnotherBar[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // /propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|<get-propertyWholeMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // /propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|<set-propertyWholeMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithFoo // /propertyWholeMarkedWithFoo|{}propertyWholeMarkedWithFoo[0]
+    final fun <get-propertyWholeMarkedWithFoo>(): kotlin/String // /propertyWholeMarkedWithFoo.<get-propertyWholeMarkedWithFoo>|<get-propertyWholeMarkedWithFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithFoo>(kotlin/String) // /propertyWholeMarkedWithFoo.<set-propertyWholeMarkedWithFoo>|<set-propertyWholeMarkedWithFoo>(kotlin.String){}[0]
+final fun /functionMarkedWithAnotherBar(): kotlin/String // /functionMarkedWithAnotherBar|functionMarkedWithAnotherBar(){}[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun /functionMarkedWithFoo(): kotlin/String // /functionMarkedWithFoo|functionMarkedWithFoo(){}[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_2.kt

@@ -0,0 +1,116 @@
+// NON_PUBLIC_MARKERS: one.two/Three.Four five.six/Seven.Eight /Foo nine.ten/Eleven.Twelve
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_2.v1.txt

@@ -0,0 +1,176 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_2>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|-5645683436151566731[0]
+}
+final class /ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar { // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithFoo // /ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|-5645683436151566731[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // /NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // /propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|7768138341638919361[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // /propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|7757487364805814175[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+final var /propertyWholeMarkedWithAnotherBar // /propertyWholeMarkedWithAnotherBar|9162962495777663780[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // /propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|-1161906039333473922[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // /propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|-4350706110481715922[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final fun /functionMarkedWithAnotherBar(): kotlin/String // /functionMarkedWithAnotherBar|-2313438891947829111[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|-4713248467320396269[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_2.v2.txt

@@ -0,0 +1,176 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_2>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|<init>(){}[0]
+}
+final class /ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar { // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherBar.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithFoo // /ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|<init>(){}[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // /NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // /propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|<get-propertyGetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // /propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|<set-propertySetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+final var /propertyWholeMarkedWithAnotherBar // /propertyWholeMarkedWithAnotherBar|{}propertyWholeMarkedWithAnotherBar[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // /propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|<get-propertyWholeMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // /propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|<set-propertyWholeMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final fun /functionMarkedWithAnotherBar(): kotlin/String // /functionMarkedWithAnotherBar|functionMarkedWithAnotherBar(){}[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_3.kt

@@ -0,0 +1,116 @@
+// NON_PUBLIC_MARKERS: one.two/Three.Four five.six/Seven.Eight /Foo /Another.Bar nine.ten/Eleven.Twelve
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_3.v1.txt

@@ -0,0 +1,123 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_3>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|-5645683436151566731[0]
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class /ClassWithConstructorMarkedWithFoo // /ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|-5645683436151566731[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|-4713248467320396269[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_3.v2.txt

@@ -0,0 +1,123 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_3>
+final object /Another { // /Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // /Another.Bar|null[0]
+        constructor <init>() // /Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // /Another.Foo|null[0]
+        constructor <init>() // /Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class /Bar : kotlin/Annotation { // /Bar|null[0]
+    constructor <init>() // /Bar.<init>|<init>(){}[0]
+}
+final class /ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassMarkedWithBar { // /ClassMarkedWithBar|null[0]
+    constructor <init>() // /ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // /ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class /ClassWithConstructorMarkedWithAnotherBar // /ClassWithConstructorMarkedWithAnotherBar|null[0]
+final class /ClassWithConstructorMarkedWithAnotherFoo { // /ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithBar { // /ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // /ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class /ClassWithConstructorMarkedWithFoo // /ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class /Foo : kotlin/Annotation { // /Foo|null[0]
+    constructor <init>() // /Foo.<init>|<init>(){}[0]
+}
+final class /NonMarkedClass { // /NonMarkedClass|null[0]
+    constructor <init>() // /NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // /NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // /NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // /NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // /NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // /NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var /nonMarkedProperty // /nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // /nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // /nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherBar // /propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // /propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithAnotherFoo // /propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // /propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // /propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithBar // /propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // /propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // /propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertyGetterMarkedWithFoo // /propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // /propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithAnotherBar // /propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // /propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+final var /propertySetterMarkedWithAnotherFoo // /propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // /propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // /propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertySetterMarkedWithBar // /propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // /propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // /propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var /propertySetterMarkedWithFoo // /propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // /propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+final var /propertyWholeMarkedWithAnotherFoo // /propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // /propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // /propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var /propertyWholeMarkedWithBar // /propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // /propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // /propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final fun /functionMarkedWithAnotherFoo(): kotlin/String // /functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun /functionMarkedWithBar(): kotlin/String // /functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun /nonMarkedFunction(): kotlin/String // /nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_4.kt

@@ -0,0 +1,118 @@
+// NON_PUBLIC_MARKERS: one.two/Three.Four five.six/Seven.Eight non_public_markers.test/Foo nine.ten/Eleven.Twelve
+
+package non_public_markers.test
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_4.v1.txt

@@ -0,0 +1,176 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_4>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|7768138341638919361[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|7757487364805814175[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherBar // non_public_markers.test/propertyWholeMarkedWithAnotherBar|9162962495777663780[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|-1161906039333473922[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|-4350706110481715922[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final fun non_public_markers.test/functionMarkedWithAnotherBar(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherBar|-2313438891947829111[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|-4713248467320396269[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_4.v2.txt

@@ -0,0 +1,176 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_4>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|<get-propertyGetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|<set-propertySetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherBar // non_public_markers.test/propertyWholeMarkedWithAnotherBar|{}propertyWholeMarkedWithAnotherBar[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|<get-propertyWholeMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|<set-propertyWholeMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final fun non_public_markers.test/functionMarkedWithAnotherBar(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherBar|functionMarkedWithAnotherBar(){}[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_5.kt

@@ -0,0 +1,118 @@
+// NON_PUBLIC_MARKERS: one.two/Three.Four five.six/Seven.Eight non_public_markers.test/Foo non_public_markers.test/Another.Bar nine.ten/Eleven.Twelve
+
+package non_public_markers.test
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_5.v1.txt

@@ -0,0 +1,123 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_5>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|-4713248467320396269[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_5.v2.txt

@@ -0,0 +1,123 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_5>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_private_annotations.kt

@@ -0,0 +1,41 @@
+// NON_PUBLIC_MARKERS: /PublicAnnotation /InternalAnnotation /PrivateAnnotation /PublicContainer.PublicAnnotation /PublicContainer.InternalAnnotation /InternalContainer.PublicAnnotation /InternalContainer.InternalAnnotation /PrivateContainer.PublicAnnotation /PrivateContainer.InternalAnnotation
+
+annotation class PublicAnnotation
+internal annotation class InternalAnnotation
+private annotation class PrivateAnnotation
+
+object PublicContainer {
+    annotation class PublicAnnotation
+    internal annotation class InternalAnnotation
+    //private annotation class PrivateAnnotation // the annotation is inaccessible from outside PublicContainer
+}
+
+internal object InternalContainer {
+    annotation class PublicAnnotation
+    internal annotation class InternalAnnotation
+    //private annotation class PrivateAnnotation // the annotation is inaccessible from outside PublicContainer
+}
+
+private object PrivateContainer {
+    annotation class PublicAnnotation
+    @Suppress("RedundantVisibilityModifier") internal annotation class InternalAnnotation
+    //private annotation class PrivateAnnotation // the annotation is inaccessible from outside PublicContainer
+}
+
+fun nonMarked() = Unit
+
+@PublicAnnotation fun markedWithPublicAnnotation() = Unit
+@InternalAnnotation fun markedWithInternalAnnotation() = Unit
+@PrivateAnnotation fun markedWithPrivateAnnotation() = Unit
+
+@PublicContainer.PublicAnnotation fun markedWithPublicContainerPublicAnnotation() = Unit
+@PublicContainer.InternalAnnotation fun markedWithPublicContainerInternalAnnotation() = Unit
+//@PublicContainer.PrivateAnnotation fun markedWithPublicContainerPrivateAnnotation() = Unit // the annotation is inaccessible from outside PublicContainer
+
+@InternalContainer.PublicAnnotation fun markedWithInternalContainerPublicAnnotation() = Unit
+@InternalContainer.InternalAnnotation fun markedWithInternalContainerInternalAnnotation() = Unit
+//@InternalContainer.PrivateAnnotation fun markedWithInternalContainerPrivateAnnotation() = Unit // the annotation is inaccessible from outside PublicContainer
+
+@PrivateContainer.PublicAnnotation fun markedWithPrivateContainerPublicAnnotation() = Unit
+@PrivateContainer.InternalAnnotation fun markedWithPrivateContainerInternalAnnotation() = Unit
+//@PrivateContainer.PrivateAnnotation fun markedWithPrivateContainerPrivateAnnotation() = Unit // the annotation is inaccessible from outside PublicContainer

compiler/util-klib-abi/testData/content/with_non_public_markers_private_annotations.v1.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_private_annotations>
+open annotation class /PublicAnnotation : kotlin/Annotation { // /PublicAnnotation|null[0]
+    constructor <init>() // /PublicAnnotation.<init>|-5645683436151566731[0]
+}
+final object /PublicContainer { // /PublicContainer|null[0]
+    open annotation class PublicAnnotation : kotlin/Annotation { // /PublicContainer.PublicAnnotation|null[0]
+        constructor <init>() // /PublicContainer.PublicAnnotation.<init>|-5645683436151566731[0]
+    }
+}
+final fun /nonMarked() // /nonMarked|1540552588547139536[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_private_annotations.v2.txt

@@ -0,0 +1,15 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_private_annotations>
+open annotation class /PublicAnnotation : kotlin/Annotation { // /PublicAnnotation|null[0]
+    constructor <init>() // /PublicAnnotation.<init>|<init>(){}[0]
+}
+final object /PublicContainer { // /PublicContainer|null[0]
+    open annotation class PublicAnnotation : kotlin/Annotation { // /PublicContainer.PublicAnnotation|null[0]
+        constructor <init>() // /PublicContainer.PublicAnnotation.<init>|<init>(){}[0]
+    }
+}
+final fun /nonMarked() // /nonMarked|nonMarked(){}[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_unspecified.kt

@@ -0,0 +1,118 @@
+// NON_PUBLIC_MARKERS:
+
+package non_public_markers.test
+
+annotation class Foo
+annotation class Bar
+
+object Another {
+    annotation class Foo
+    annotation class Bar
+}
+
+class NonMarkedClass {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Foo class ClassMarkedWithFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Bar class ClassMarkedWithAnotherFoo {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Foo class ClassMarkedWithBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+@Another.Bar class ClassMarkedWithAnotherBar {
+    class NonMarkedClass {
+        class NonMarkedClass
+        @Foo class ClassMarkedWithFoo
+        @Bar class ClassMarkedWithAnotherFoo
+        @Another.Foo class ClassMarkedWithBar
+        @Another.Bar class ClassMarkedWithAnotherBar
+    }
+    @Foo class ClassMarkedWithFoo
+    @Bar class ClassMarkedWithAnotherFoo
+    @Another.Foo class ClassMarkedWithBar
+    @Another.Bar class ClassMarkedWithAnotherBar
+}
+
+class ClassWithConstructorMarkedWithFoo @Foo constructor()
+class ClassWithConstructorMarkedWithAnotherFoo @Another.Foo constructor()
+class ClassWithConstructorMarkedWithBar @Bar constructor()
+class ClassWithConstructorMarkedWithAnotherBar @Another.Bar constructor()
+
+fun nonMarkedFunction(): String = ""
+@Foo fun functionMarkedWithFoo(): String = ""
+@Bar fun functionMarkedWithAnotherFoo(): String = ""
+@Another.Foo fun functionMarkedWithBar(): String = ""
+@Another.Bar fun functionMarkedWithAnotherBar(): String = ""
+
+var nonMarkedProperty: String get() = ""
+    set(_) = Unit
+
+@Foo var propertyWholeMarkedWithFoo: String get() = ""
+    set(_) = Unit
+@Another.Foo var propertyWholeMarkedWithAnotherFoo: String get() = ""
+    set(_) = Unit
+@Bar var propertyWholeMarkedWithBar: String get() = ""
+    set(_) = Unit
+@Another.Bar var propertyWholeMarkedWithAnotherBar: String get() = ""
+    set(_) = Unit
+
+var propertyGetterMarkedWithFoo: String @Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherFoo: String @Another.Foo get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithBar: String @Bar get() = ""
+    set(_) = Unit
+var propertyGetterMarkedWithAnotherBar: String @Another.Bar get() = ""
+    set(_) = Unit
+
+var propertySetterMarkedWithFoo: String get() = ""
+    @Foo set(_) = Unit
+var propertySetterMarkedWithAnotherFoo: String get() = ""
+    @Another.Foo set(_) = Unit
+var propertySetterMarkedWithBar: String get() = ""
+    @Bar set(_) = Unit
+var propertySetterMarkedWithAnotherBar: String get() = ""
+    @Another.Bar set(_) = Unit

compiler/util-klib-abi/testData/content/with_non_public_markers_unspecified.v1.txt

@@ -0,0 +1,241 @@
+// Rendering settings:
+// - Signature version: 1
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_unspecified>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|-5645683436151566731[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|-5645683436151566731[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo { // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithFoo.<init>|-5645683436151566731[0]
+}
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|-5645683436151566731[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|-5645683436151566731[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|-5645683436151566731[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo.<init>|-5645683436151566731[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|-5645683436151566731[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|2555039021383536112[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|3521952790317234139[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|-1967656686156177486[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|-8321084504405299502[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|7768138341638919361[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|1952287206559835979[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|839569568647204104[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|1487266266209481670[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|-8358141007331692807[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|-1638684334333087309[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|6425367069051405147[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|-7277763711448582747[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|-1600129117215170169[0]
+    final fun <get-propertyGetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithFoo.<get-propertyGetterMarkedWithFoo>|7715429316947815497[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|6101825374130458315[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|5611678287610594662[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|-2853824538371026163[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|7757487364805814175[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|-6739876303163327450[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|6152184411550223957[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|5641698148509098165[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|-1734653558734028189[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|8631669627377921573[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|7103802845088436414[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|1014214022435246726[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|-717220786783485579[0]
+    final fun <set-propertySetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithFoo.<set-propertySetterMarkedWithFoo>|-5398085748280780705[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherBar // non_public_markers.test/propertyWholeMarkedWithAnotherBar|9162962495777663780[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|-1161906039333473922[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|-4350706110481715922[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|7767984100232675887[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|7102392919901087513[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|3373183467277540973[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|-119318583651089964[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|5964037984201295529[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|-2146460773497366334[0]
+final var non_public_markers.test/propertyWholeMarkedWithFoo // non_public_markers.test/propertyWholeMarkedWithFoo|1235853922868560214[0]
+    final fun <get-propertyWholeMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithFoo.<get-propertyWholeMarkedWithFoo>|-8118247767275252666[0]
+    final fun <set-propertyWholeMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithFoo.<set-propertyWholeMarkedWithFoo>|1985764616902292422[0]
+final fun non_public_markers.test/functionMarkedWithAnotherBar(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherBar|-2313438891947829111[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|-5357424157245366714[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|-4713248467320396269[0]
+final fun non_public_markers.test/functionMarkedWithFoo(): kotlin/String // non_public_markers.test/functionMarkedWithFoo|5454702469127665692[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|463145417007613104[0]

compiler/util-klib-abi/testData/content/with_non_public_markers_unspecified.v2.txt

@@ -0,0 +1,241 @@
+// Rendering settings:
+// - Signature version: 2
+// - Show manifest properties: false
+// - Show declarations: true
+
+// Library unique name: <testWith_non_public_markers_unspecified>
+final object non_public_markers.test/Another { // non_public_markers.test/Another|null[0]
+    open annotation class Bar : kotlin/Annotation { // non_public_markers.test/Another.Bar|null[0]
+        constructor <init>() // non_public_markers.test/Another.Bar.<init>|<init>(){}[0]
+    }
+    open annotation class Foo : kotlin/Annotation { // non_public_markers.test/Another.Foo|null[0]
+        constructor <init>() // non_public_markers.test/Another.Foo.<init>|<init>(){}[0]
+    }
+}
+open annotation class non_public_markers.test/Bar : kotlin/Annotation { // non_public_markers.test/Bar|null[0]
+    constructor <init>() // non_public_markers.test/Bar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithAnotherFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithBar.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithBar.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/ClassMarkedWithFoo.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherBar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo { // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithAnotherFoo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithBar { // non_public_markers.test/ClassWithConstructorMarkedWithBar|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithBar.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/ClassWithConstructorMarkedWithFoo { // non_public_markers.test/ClassWithConstructorMarkedWithFoo|null[0]
+    constructor <init>() // non_public_markers.test/ClassWithConstructorMarkedWithFoo.<init>|<init>(){}[0]
+}
+open annotation class non_public_markers.test/Foo : kotlin/Annotation { // non_public_markers.test/Foo|null[0]
+    constructor <init>() // non_public_markers.test/Foo.<init>|<init>(){}[0]
+}
+final class non_public_markers.test/NonMarkedClass { // non_public_markers.test/NonMarkedClass|null[0]
+    constructor <init>() // non_public_markers.test/NonMarkedClass.<init>|<init>(){}[0]
+    final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+    }
+    final class ClassMarkedWithFoo { // non_public_markers.test/NonMarkedClass.ClassMarkedWithFoo|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+    }
+    final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass|null[0]
+        constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        final class ClassMarkedWithAnotherBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithAnotherFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithAnotherFoo.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithBar { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithBar.<init>|<init>(){}[0]
+        }
+        final class ClassMarkedWithFoo { // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.ClassMarkedWithFoo.<init>|<init>(){}[0]
+        }
+        final class NonMarkedClass { // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass|null[0]
+            constructor <init>() // non_public_markers.test/NonMarkedClass.NonMarkedClass.NonMarkedClass.<init>|<init>(){}[0]
+        }
+    }
+}
+final var non_public_markers.test/nonMarkedProperty // non_public_markers.test/nonMarkedProperty|{}nonMarkedProperty[0]
+    final fun <get-nonMarkedProperty>(): kotlin/String // non_public_markers.test/nonMarkedProperty.<get-nonMarkedProperty>|<get-nonMarkedProperty>(){}[0]
+    final fun <set-nonMarkedProperty>(kotlin/String) // non_public_markers.test/nonMarkedProperty.<set-nonMarkedProperty>|<set-nonMarkedProperty>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherBar // non_public_markers.test/propertyGetterMarkedWithAnotherBar|{}propertyGetterMarkedWithAnotherBar[0]
+    final fun <get-propertyGetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<get-propertyGetterMarkedWithAnotherBar>|<get-propertyGetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherBar.<set-propertyGetterMarkedWithAnotherBar>|<set-propertyGetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithAnotherFoo // non_public_markers.test/propertyGetterMarkedWithAnotherFoo|{}propertyGetterMarkedWithAnotherFoo[0]
+    final fun <get-propertyGetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<get-propertyGetterMarkedWithAnotherFoo>|<get-propertyGetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithAnotherFoo.<set-propertyGetterMarkedWithAnotherFoo>|<set-propertyGetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithBar // non_public_markers.test/propertyGetterMarkedWithBar|{}propertyGetterMarkedWithBar[0]
+    final fun <get-propertyGetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithBar.<get-propertyGetterMarkedWithBar>|<get-propertyGetterMarkedWithBar>(){}[0]
+    final fun <set-propertyGetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithBar.<set-propertyGetterMarkedWithBar>|<set-propertyGetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyGetterMarkedWithFoo // non_public_markers.test/propertyGetterMarkedWithFoo|{}propertyGetterMarkedWithFoo[0]
+    final fun <get-propertyGetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertyGetterMarkedWithFoo.<get-propertyGetterMarkedWithFoo>|<get-propertyGetterMarkedWithFoo>(){}[0]
+    final fun <set-propertyGetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyGetterMarkedWithFoo.<set-propertyGetterMarkedWithFoo>|<set-propertyGetterMarkedWithFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherBar // non_public_markers.test/propertySetterMarkedWithAnotherBar|{}propertySetterMarkedWithAnotherBar[0]
+    final fun <get-propertySetterMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherBar.<get-propertySetterMarkedWithAnotherBar>|<get-propertySetterMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherBar.<set-propertySetterMarkedWithAnotherBar>|<set-propertySetterMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithAnotherFoo // non_public_markers.test/propertySetterMarkedWithAnotherFoo|{}propertySetterMarkedWithAnotherFoo[0]
+    final fun <get-propertySetterMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<get-propertySetterMarkedWithAnotherFoo>|<get-propertySetterMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithAnotherFoo.<set-propertySetterMarkedWithAnotherFoo>|<set-propertySetterMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithBar // non_public_markers.test/propertySetterMarkedWithBar|{}propertySetterMarkedWithBar[0]
+    final fun <get-propertySetterMarkedWithBar>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithBar.<get-propertySetterMarkedWithBar>|<get-propertySetterMarkedWithBar>(){}[0]
+    final fun <set-propertySetterMarkedWithBar>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithBar.<set-propertySetterMarkedWithBar>|<set-propertySetterMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertySetterMarkedWithFoo // non_public_markers.test/propertySetterMarkedWithFoo|{}propertySetterMarkedWithFoo[0]
+    final fun <get-propertySetterMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertySetterMarkedWithFoo.<get-propertySetterMarkedWithFoo>|<get-propertySetterMarkedWithFoo>(){}[0]
+    final fun <set-propertySetterMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertySetterMarkedWithFoo.<set-propertySetterMarkedWithFoo>|<set-propertySetterMarkedWithFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherBar // non_public_markers.test/propertyWholeMarkedWithAnotherBar|{}propertyWholeMarkedWithAnotherBar[0]
+    final fun <get-propertyWholeMarkedWithAnotherBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<get-propertyWholeMarkedWithAnotherBar>|<get-propertyWholeMarkedWithAnotherBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherBar.<set-propertyWholeMarkedWithAnotherBar>|<set-propertyWholeMarkedWithAnotherBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithAnotherFoo // non_public_markers.test/propertyWholeMarkedWithAnotherFoo|{}propertyWholeMarkedWithAnotherFoo[0]
+    final fun <get-propertyWholeMarkedWithAnotherFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<get-propertyWholeMarkedWithAnotherFoo>|<get-propertyWholeMarkedWithAnotherFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithAnotherFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithAnotherFoo.<set-propertyWholeMarkedWithAnotherFoo>|<set-propertyWholeMarkedWithAnotherFoo>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithBar // non_public_markers.test/propertyWholeMarkedWithBar|{}propertyWholeMarkedWithBar[0]
+    final fun <get-propertyWholeMarkedWithBar>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithBar.<get-propertyWholeMarkedWithBar>|<get-propertyWholeMarkedWithBar>(){}[0]
+    final fun <set-propertyWholeMarkedWithBar>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithBar.<set-propertyWholeMarkedWithBar>|<set-propertyWholeMarkedWithBar>(kotlin.String){}[0]
+final var non_public_markers.test/propertyWholeMarkedWithFoo // non_public_markers.test/propertyWholeMarkedWithFoo|{}propertyWholeMarkedWithFoo[0]
+    final fun <get-propertyWholeMarkedWithFoo>(): kotlin/String // non_public_markers.test/propertyWholeMarkedWithFoo.<get-propertyWholeMarkedWithFoo>|<get-propertyWholeMarkedWithFoo>(){}[0]
+    final fun <set-propertyWholeMarkedWithFoo>(kotlin/String) // non_public_markers.test/propertyWholeMarkedWithFoo.<set-propertyWholeMarkedWithFoo>|<set-propertyWholeMarkedWithFoo>(kotlin.String){}[0]
+final fun non_public_markers.test/functionMarkedWithAnotherBar(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherBar|functionMarkedWithAnotherBar(){}[0]
+final fun non_public_markers.test/functionMarkedWithAnotherFoo(): kotlin/String // non_public_markers.test/functionMarkedWithAnotherFoo|functionMarkedWithAnotherFoo(){}[0]
+final fun non_public_markers.test/functionMarkedWithBar(): kotlin/String // non_public_markers.test/functionMarkedWithBar|functionMarkedWithBar(){}[0]
+final fun non_public_markers.test/functionMarkedWithFoo(): kotlin/String // non_public_markers.test/functionMarkedWithFoo|functionMarkedWithFoo(){}[0]
+final fun non_public_markers.test/nonMarkedFunction(): kotlin/String // non_public_markers.test/nonMarkedFunction|nonMarkedFunction(){}[0]

compiler/util-klib-abi/tests-gen/org/jetbrains/kotlin/library/abi/LibraryAbiReaderTest.java

@@ -0,0 +1,176 @@
+/*
+ * Copyright 2010-2023 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.kotlin.library.abi;
+
+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 org.jetbrains.kotlin.library.abi.GenerateLibraryAbiReaderTestsKt}. DO NOT MODIFY MANUALLY */
+@SuppressWarnings("all")
+@TestMetadata("compiler/util-klib-abi/testData/content")
+@TestDataPath("$PROJECT_ROOT")
+public class LibraryAbiReaderTest extends AbstractLibraryAbiReaderTest {
+    @Test
+    public void testAllFilesPresentInContent() throws Exception {
+        KtTestUtil.assertAllTestsPresentByMetadataWithExcluded(this.getClass(), new File("compiler/util-klib-abi/testData/content"), Pattern.compile("^(.+)\\.kt$"), null, true);
+    }
+
+    @Test
+    @TestMetadata("callables.kt")
+    public void testCallables() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/callables.kt");
+    }
+
+    @Test
+    @TestMetadata("classifiers.kt")
+    public void testClassifiers() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/classifiers.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_classes_1.kt")
+    public void testExcluded_classes_1() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_classes_1.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_classes_2.kt")
+    public void testExcluded_classes_2() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_classes_2.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_classes_3.kt")
+    public void testExcluded_classes_3() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_classes_3.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_classes_unspecified.kt")
+    public void testExcluded_classes_unspecified() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_classes_unspecified.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_non_root_1.kt")
+    public void testExcluded_packages_non_root_1() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_non_root_1.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_non_root_2.kt")
+    public void testExcluded_packages_non_root_2() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_non_root_2.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_non_root_3.kt")
+    public void testExcluded_packages_non_root_3() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_non_root_3.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_non_root_4.kt")
+    public void testExcluded_packages_non_root_4() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_non_root_4.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_root_1.kt")
+    public void testExcluded_packages_root_1() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_root_1.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_root_2.kt")
+    public void testExcluded_packages_root_2() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_root_2.kt");
+    }
+
+    @Test
+    @TestMetadata("excluded_packages_unspecified.kt")
+    public void testExcluded_packages_unspecified() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/excluded_packages_unspecified.kt");
+    }
+
+    @Test
+    @TestMetadata("inheritance.kt")
+    public void testInheritance() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/inheritance.kt");
+    }
+
+    @Test
+    @TestMetadata("root_package.kt")
+    public void testRoot_package() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/root_package.kt");
+    }
+
+    @Test
+    @TestMetadata("type_parameters.kt")
+    public void testType_parameters() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/type_parameters.kt");
+    }
+
+    @Test
+    @TestMetadata("value_parameters.kt")
+    public void testValue_parameters() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/value_parameters.kt");
+    }
+
+    @Test
+    @TestMetadata("visibilities.kt")
+    public void testVisibilities() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/visibilities.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_1.kt")
+    public void testWith_non_public_markers_1() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_1.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_2.kt")
+    public void testWith_non_public_markers_2() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_2.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_3.kt")
+    public void testWith_non_public_markers_3() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_3.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_4.kt")
+    public void testWith_non_public_markers_4() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_4.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_5.kt")
+    public void testWith_non_public_markers_5() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_5.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_private_annotations.kt")
+    public void testWith_non_public_markers_private_annotations() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_private_annotations.kt");
+    }
+
+    @Test
+    @TestMetadata("with_non_public_markers_unspecified.kt")
+    public void testWith_non_public_markers_unspecified() throws Exception {
+        runTest("compiler/util-klib-abi/testData/content/with_non_public_markers_unspecified.kt");
+    }
+}

compiler/util-klib/src/org/jetbrains/kotlin/library/KotlinLibraryVersioning.kt

@@ -33,6 +33,7 @@ fun Properties.readKonanLibraryVersioning(): KotlinLibraryVersioning {
     // If there is no such property in the manifest, it means that the manifest was generated by an older version of the compiler,
     // meaning that it only contains v1 signatures.
     val irSignatureVersions = this.getProperty(KLIB_PROPERTY_IR_SIGNATURE_VERSIONS)?.parseIrSignatureVersions()
+        ?.also { check(it.isNotEmpty()) { "Malformed manifest: Empty set of IR signature versions" } }
         ?: setOf(KotlinIrSignatureVersion.V1)
 
     return KotlinLibraryVersioning(

settings.gradle

@@ -36,6 +36,7 @@ include ":benchmarks",
         ":kotlin-util-io",
         ":kotlin-util-klib",
         ":kotlin-util-klib-metadata",
+        ":kotlin-util-klib-abi",
         ":daemon-common",
         ":kotlin-daemon",
         ":kotlin-daemon-client",
@@ -677,6 +678,7 @@ project(':compiler:ir.interpreter').projectDir = "$rootDir/compiler/ir/ir.interp
 project(':kotlin-util-io').projectDir = "$rootDir/compiler/util-io" as File
 project(':kotlin-util-klib').projectDir = "$rootDir/compiler/util-klib" as File
 project(':kotlin-util-klib-metadata').projectDir = "$rootDir/compiler/util-klib-metadata" as File
+project(':kotlin-util-klib-abi').projectDir = "$rootDir/compiler/util-klib-abi" as File
 project(':native:kotlin-native-utils').projectDir = "$rootDir/native/utils" as File
 project(':native:frontend.native').projectDir = "$rootDir/native/frontend" as File
 project(':native:kotlin-klib-commonizer').projectDir = "$rootDir/native/commonizer" as File