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,

                                    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,

    def parsesShortOptionWithArgument() {
        parser.option('a').hasArgument()

        expect:
        def result = parser.parse(['-a', 'arg'])
        result.hasOption('a')
        result.option('a').value == 'arg'
        result.option('a').values == ['arg']
    }

    def parsesShortOptionWithAttachedArgument() {
        parser.option('a').hasArgument()

        expect:
        def result = parser.parse(['-aarg'])