override val useSiteTarget: AnnotationUseSiteTarget?
        get() = withValidityAssertion { backingUseSiteTarget }

    private val backingHasArguments: Boolean = hasArguments

    override val hasArguments: Boolean
        get() = withValidityAssertion { backingHasArguments }

    private val backingArguments: List<KaNamedAnnotationValue> by lazyArguments

     * then you can avoid [KaAnnotated.annotationsByClassId] call,
     * because effectively you already have all necessary information in [KaAnnotationApplicationInfo]
     */
    public val hasArguments: Boolean

    @Deprecated("Use 'hasArguments' instead.", replaceWith = ReplaceWith("hasArguments"))
    public val isCallWithArguments: Boolean

        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {
            configureCommandLineOption(parser, config.getAllOptions(), config.getDescription(), config.isDeprecated(), config.isIncubating()).hasArguments();
        }
    }

    @Override
    public void applyFromCommandLine(ParsedCommandLine options, T settings) {
        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {

    val classId = toAnnotationClassId(builder.rootSession)

    return KaAnnotationImpl(
        classId = classId,
        psi = psi as? KtCallElement,
        useSiteTarget = useSiteTarget,
        hasArguments = this is FirAnnotationCall && this.arguments.isNotEmpty(),
        lazyArguments = lazy { argumentsFactory(classId) },
        index = index,
        constructorSymbol = constructorSymbol,
        token = builder.token,

                                    psi = psi as? KtCallElement,
                                    useSiteTarget = null,
                                    hasArguments = arguments.isNotEmpty(),
                                    lazyArguments = lazy { toNamedConstantValue(builder.analysisSession, resultMap, builder) },
                                    index = null,

                KaAnnotationImpl(
                    value.annotationClass?.classId,
                    psi = null,
                    useSiteTarget = null,
                    hasArguments = value.allValueArguments.isNotEmpty(),
                    lazyArguments = lazy { value.getKtNamedAnnotationArguments(analysisContext) },
                    index = null,
                    constructorSymbol = null,

    @get:InputDirectory
    @get:PathSensitive(PathSensitivity.RELATIVE)
    abstract val repoLocation: DirectoryProperty

    @get:Input
    abstract val kotlinVersion: Property<String>

    override fun asArguments() =
        listOf(
            "-DintegTest.apiJarRepoLocation=${repoLocation.get().asFile.absolutePath}",
            "-DintegTest.kotlinVersion=${kotlinVersion.get()}"
        )
}

                @InputFile
                @PathSensitive(PathSensitivity.NONE)
                abstract RegularFileProperty getInputFile()

                @Override
                Iterable<String> asArguments() {
                    return ["-Dinput.file=\${inputFile.get().asFile.absolutePath}".toString()]
                }
            }

        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {
            configureCommandLineOption(parser, config.getAllOptions(), config.getDescription(), config.isDeprecated(), config.isIncubating()).hasArgument();
        }
    }

    @Override
    public void applyFromCommandLine(ParsedCommandLine options, T settings) {
        for (CommandLineOptionConfiguration config : commandLineOptionConfigurations) {

class CiEnvironmentProvider(private val test: Test) : CommandLineArgumentProvider, Named {
    @Internal
    override fun getName() = "ciEnvironment"

    override fun asArguments(): Iterable<String> {
        return if (BuildEnvironment.isCiServer) {
            getRepoMirrorSystemProperties() +
                getToolchainInstallationPathsProperty() +
                mapOf(