private
    fun newConstructorForSerialization(beanType: Class<*>, constructor: Constructor<*>): Constructor<out Any> =
        ReflectionFactory.getReflectionFactory().newConstructorForSerialization(beanType, constructor)

/**
 * State might be corrupted and should be discarded.
 */
@Contextual
class ConfigurationCacheError internal constructor(
    error: String,
    cause: Throwable? = null
) : ConfigurationCacheThrowable, Exception(error, cause)


@Contextual
sealed class ConfigurationCacheException protected constructor(
    message: () -> String,
    causes: Iterable<Throwable>

}

public typealias KtAnnotationValue = KaAnnotationValue

/**
 * This represents an unsupported expression used as an annotation value.
 */
public class KaUnsupportedAnnotationValue @KaAnalysisApiInternals constructor(
    token: KaLifetimeToken
) : KaAnnotationValue(token) {
    override val sourcePsi: KtElement?
        get() = withValidityAssertion { null }
}

Constructor <org.gradle.language.cpp.internal.DefaultCppBinary.<init>(org.gradle.language.nativeplatform.internal.Names, org.gradle.api.model.ObjectFactory, org.gradle.api.provider.Provider, org.gradle.api.file.FileCollection, org.gradle.api.file.FileCollection, org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal, org.gradle.api.artifacts.Configuration, org.gradle.language.cpp.CppPlatform, org.gradle.nativeplatform.toolchain.internal.NativeToolChainInternal,...

        return Gson().fromJson(reader)
    }
}

inline
fun <reified T> Gson.fromJson(json: JsonReader): T = this.fromJson(json, object : TypeToken<T>() {}.type)


abstract class CapabilityRule @Inject constructor(
    val name: String,
    val version: String
) : ComponentMetadataRule {
    override fun execute(context: ComponentMetadataContext) {
        context.details.allVariants {
            withCapabilities {

 * change at any time.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({
    ElementType.PACKAGE,
    ElementType.TYPE,
    ElementType.ANNOTATION_TYPE,
    ElementType.CONSTRUCTOR,
    ElementType.FIELD,
    ElementType.METHOD
})
public @interface Incubating {

 * property.
 *
 * @since 4.0
 */
@Retention(RetentionPolicy.SOURCE)
@Target({ElementType.METHOD, ElementType.TYPE, ElementType.FIELD, ElementType.CONSTRUCTOR})
public @interface UsedByScanPlugin {

    /**
     * Any clarifying comments about how it is used.
     */
    String value() default "";

    override val projection: KaTypeProjection
        get() = withValidityAssertion { builder.typeBuilder.buildTypeProjection(coneType.constructor.projection) }

    override val annotations: KaAnnotationList by cached {
        KaFirAnnotationListForType.create(coneType, builder)
    }

    override val abbreviatedType: KaUsualClassType?

    override val nullability: KaTypeNullability
        get() = withValidityAssertion { fe10Type.ktNullability }

    override val projection: KaTypeProjection
        get() = withValidityAssertion { fe10Type.constructor.projection.toKtTypeProjection(analysisContext) }

    override val abbreviatedType: KaUsualClassType?
        get() = withValidityAssertion { null }

    override fun toString(): String {

    private final ArrayBlockingQueue<Exchange> eventQueue;

    /**
     * Constructor that makes passed in delegate run on single thread, and will block on last event.
     */
    public SimplexTransferListener(TransferListener delegate) {
        this(delegate, QUEUE_SIZE, BATCH_MAX_SIZE, true);
    }

    /**
     * Constructor that may alter behaviour of this listener.
     *