/**
 * Specify the version of the plugin to depend on.
 *
 * Infix version of [PluginDependencySpec.version].
 */
infix fun PluginDependencySpec.version(version: String?): PluginDependencySpec = version(version)


/**
 * Specify the version of the plugin to depend on.
 *
 * Infix version of [PluginDependencySpec.version].
 *
 * @since 7.2
 */

    @get:Restricted
    var version: String = ""

    @get:HasDefaultValue
    var apply: Boolean = false

    @Builder
    infix fun version(value: String): PluginDefinition =
        apply { version = value }

    @Builder
    infix fun apply(value: Boolean): PluginDefinition =
        apply { apply = value }

fun test(bar: String) {
    consume("foo" <expr>join</expr> bar)
}

infix fun String.join(other: String): String = this + other

    public infix fun and(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =
        KaRendererAnnotationsFilter filter@{ annotation, owner ->
            val analysisSession = this@filter
            filter(analysisSession, annotation, owner) && other.filter(analysisSession, annotation, owner)
        }

    public infix fun or(other: KaRendererAnnotationsFilter): KaRendererAnnotationsFilter =

import org.jetbrains.kotlin.lexer.KtKeywordToken

public interface KaRendererKeywordFilter {
    public fun filter(analysisSession: KaSession, modifier: KtKeywordToken, annotated: KaAnnotated): Boolean

    public infix fun and(other: KaRendererKeywordFilter): KaRendererKeywordFilter {
        val self = this
        return KaRendererKeywordFilter filter@{ modifier, kaAnnotated ->
            val analysisSession = this@filter

            if (operatorChanged) {
                changes.add(modifierChangeDetail("operator", newIsOperator))
            }
            if (infixChanged) {
                changes.add(modifierChangeDetail("infix", newIsInfix))
            }
            return acceptOrReject(member, changes, Violation.error(member, "Breaking Kotlin modifier change"))
        }

        return null
    }

    }

    @Test
    fun `accessors should not depend on execution`() {
        "..accessors.." shouldNotDependOn "..kotlin.dsl.execution.."
    }

    private
    infix fun String.shouldNotDependOn(thatPackage: String) {
        noClasses()
            .that().resideInAPackage(this)
            .should().accessClassesThat().resideInAPackage(thatPackage)
            .check(classes)
    }

import org.jetbrains.kotlin.types.Variance

public interface KaRendererOtherModifiersProvider {
    public fun getOtherModifiers(analysisSession: KaSession, symbol: KaDeclarationSymbol): List<KtModifierKeywordToken>

    public infix fun and(other: KaRendererOtherModifiersProvider): KaRendererOtherModifiersProvider {
        val self = this
        return object : KaRendererOtherModifiersProvider {