*
 * @since 8.8
 */
@DisableCachingByDefault(because = "Not worth caching")
@Incubating
public abstract class UpdateDaemonJvm extends DefaultTask {
    /**
     * Constructor.
     *
     * @since 8.8
     */
    @Inject
    public UpdateDaemonJvm() {

    }

    @TaskAction
    void generate() {
        IncubationLogger.incubatingFeatureUsed("Daemon JVM criteria");

    }
    return analysisSession.substitutorFactory.buildSubstitutor(KaSubstitutorBuilder(token).apply(build))
}


public class KaSubstitutorBuilder
@KaAnalysisApiInternals constructor(override val token: KaLifetimeToken) : KaLifetimeOwner {
    private val backingMapping = mutableMapOf<KaTypeParameterSymbol, KaType>()

 *
 * @deprecated Maven 3 compatability - please use {@link MetadataStaxWriter}
 */
@Deprecated
public class MetadataXpp3Writer {

    private final MetadataStaxWriter delegate;

    /**
     * Default constructor
     */
    public MetadataXpp3Writer() {
        delegate = new MetadataStaxWriter();
    }

    /**
     * Method setFileComment.
     *
     * @param fileComment a fileComment object.
     */

import org.jetbrains.kotlin.fir.symbols.FirBasedSymbol
import org.jetbrains.kotlin.fir.symbols.impl.FirBackingFieldSymbol
import org.jetbrains.kotlin.name.ClassId

internal class KaFirAnnotationListForDeclaration private constructor(
    val firSymbol: FirBasedSymbol<*>,
    private val builder: KaSymbolByFirBuilder,
) : AbstractList<KaAnnotation>(), KaAnnotationList {
    private val backingAnnotations by lazy { annotations(firSymbol, builder) }

import org.jetbrains.kotlin.analysis.api.lifetime.withValidityAssertion
import org.jetbrains.kotlin.descriptors.annotations.Annotations
import org.jetbrains.kotlin.name.ClassId

internal class KaFe10AnnotationList private constructor(
    private val fe10Annotations: Annotations,
    private val analysisContext: Fe10AnalysisContext,
    private val ignoredAnnotations: Set<ClassId> = emptySet()
) : AbstractList<KaAnnotation>(), KaAnnotationList {

import org.gradle.kotlin.dsl.getValue
import org.gradle.kotlin.dsl.register
import org.gradle.kotlin.dsl.named
import javax.inject.Inject

// tag::inject_software_component_factory[]
class InstrumentedJarsPlugin @Inject constructor(
    private val softwareComponentFactory: SoftwareComponentFactory) : Plugin<Project> {
// end::inject_software_component_factory[]

    override fun apply(project: Project) = project.run {

     * It may however contain more than one entry if module hierarchy was detected,
     * in which case there is one key per sub-directory.
     *
     * <p>This map may contain null values if the constructor was invoked with {@code resolve}
     * parameter set to false. This is more efficient when only the module existence needs to
     * be tested, and module descriptors are not needed.</p>
     *
     * @see #getModuleNames()

     */
    public val index: Int?

    /**
     * A list of explicitly provided annotation values.
     */
    public val arguments: List<KaNamedAnnotationValue>

    /**
     * An annotation constructor symbol.
     */
    public val constructorSymbol: KaConstructorSymbol?

    @Deprecated("Use 'constructorSymbol' instead.")
    public val constructorSymbolPointer: KaSymbolPointer<KaConstructorSymbol>?

import org.jetbrains.kotlin.name.FqName
import org.jetbrains.kotlin.name.Name
import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.utils.flatMapToNullableSet

public class KotlinCompositeDeclarationProvider private constructor(
    override val providers: List<KotlinDeclarationProvider>
) : KotlinDeclarationProvider(), KotlinCompositeProvider<KotlinDeclarationProvider> {

        visitFailures(results2) == [throwable]
        visitFailures(results3) == [resolveEx]
        visitFailures(results4) == [throwable, resolveEx]
    }

    def "getters return the values passed to the constructor"() {
        given:
        def resolveEx = Mock(ResolveException)
        def unresolved = Mock(UnresolvedDependency)