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

        def option = Mock(CommandLineOption);
        setup:
            parser.option(_,_) >> option
            option.hasArguments() >> option
            option.hasDescription(_) >> option
        when:
            converter.configure(parser)
        then:
            1 * option.hasArguments() >> option
            1 * option.hasDescription(converter.propertyOptionDescription) >> option

    @Override
    public void configure(CommandLineParser parser) {
        CommandLineOption option = parser.option(getPropertyOption(), getPropertyOptionDetailed());
        option = option.hasArguments();
        option.hasDescription(getPropertyOptionDescription());
    }

    @Override
    public Map<String, String> convert(ParsedCommandLine options, Map<String, String> properties) throws CommandLineArgumentException {

        return options;
    }

    public CommandLineOption hasArgument(Class<?> argumentType) {
        this.argumentType = argumentType;
        return this;
    }

    public CommandLineOption hasArgument() {
        this.argumentType = String.class;
        return this;
    }

    public CommandLineOption hasArguments() {
        argumentType = List.class;
        return this;
    }

        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,

    @InputDirectory
    @PathSensitive(PathSensitivity.RELATIVE)  // <2>
    abstract DirectoryProperty getDistribution()

    @Override
    Iterable<String> asArguments() {
        ["-Ddistribution.location=${distribution.get().asFile.absolutePath}"]  // <3>
    }
}

tasks.named('integTest') {
    jvmArgumentProviders.add(

abstract class DistributionLocationProvider : CommandLineArgumentProvider {  // <1>
    @get:InputDirectory
    @get:PathSensitive(PathSensitivity.RELATIVE)  // <2>
    abstract val distribution: DirectoryProperty

    override fun asArguments(): Iterable<String> =
        listOf("-Ddistribution.location=${distribution.get().asFile.absolutePath}")  // <3>
}

tasks.integTest {
    jvmArgumentProviders.add(

class AddOpensArgProvider implements CommandLineArgumentProvider {
    private final Test test;
    public AddOpensArgProvider(Test test) {
        this.test = test;
    }
    @Override
    Iterable<String> asArguments() {
        return test.javaVersion.isCompatibleWith(JavaVersion.VERSION_1_9)
            ? ["--add-opens=java.base/java.lang=ALL-UNNAMED"]
            : []
    }
}
tasks.withType(Test).configureEach {