KotlinLexer().let { lexer ->
        lexer.start(input)
        this(lexer)
    }


internal
class ParserRef<T> {
    operator fun getValue(t: Any?, property: KProperty<*>): Parser<T> =
        ref

    operator fun setValue(t: Any?, property: KProperty<*>, value: Parser<T>) {
        parser = value
    }

    private
    var parser: Parser<T> = { error("Parser cannot be used while it's being constructed") }

    }

    private fun KaSession.renderProperty(
        property: KProperty<*>,
        printer: PrettyPrinter,
        renderSymbolsFully: Boolean,
        vararg args: Any,
    ) {
        printer.append(property.name).append(": ")
        renderFunctionCall(property.getter, printer, renderSymbolsFully, args)
    }

    private fun KaSession.renderFunctionCall(

        <profile>
            <id>profile-2</id>
            <activation>
                <property>
                    <name>${customPropertyName}</name>
                    <value>BLUE</value>
                </property>
            </activation>
            <properties>
                <prop2>myproperty2</prop2>
            </properties>
        </profile>
    </profiles>
</project>
"""

     * </p>
     * <p>
     * Values are not allowed to be null.
     * </p>
     *
     * @param name Name of the property
     * @param value Value of the property
     * @since 3.4
     */
    public void property(final String name, final Object value) {
        checkForNullValue(name, value);
        if (DeferredUtil.isDeferred(value)) {

/**
 * An implementation of a Groovy MetaClass that is instrumented and might need to cancel some optimizations
 * in order to get the instrumentation to work properly.
 */
public interface InstrumentedMetaClass {
    /**
     * Checks if accessing a property by the specified name would be intercepted by the instrumentation at this
     * specific moment. The implementation may return different values at different times.
     */

    /**
     * Creates a shallow copy of this property. Further changes to this property (via {@code set(...)}, or {@code convention(Object...)}) do not
     * change the copy. However, the copy still reflects changes to the underlying providers that constitute this property. Consider the following snippet:
     * <pre>
     *     def upstream = objects.property(String).value("foo")
     *     def property = objects.property(String).value(upstream)

    ArtifactHandlerScope.of(artifacts).configuration()


/**
 * Locates a property on [Project].
 */
operator fun Project.provideDelegate(any: Any?, property: KProperty<*>): PropertyDelegate =
    propertyDelegateFor(serviceOf(), this, property)


/**
 * Creates a container for managing named objects of the specified type.
 *

        property.get() == someValue()

        property.set(someOtherValue())
        property.present
        property.get() == someOtherValue()
    }

    def "can use null convention value"() {
        def property = propertyWithNoValue()
        assert property.getOrNull() != someValue()

        expect:
        nullConvention(property)

        !property.present
        property.getOrNull() == null

        and: 'conventions get properly applied'
        // check the conventions in the resolution results, they should be there, and it is independent of the DOM overlay
        def projectEvaluated = project.stepResults.values()[0] as EvaluationResult.Evaluated<AnalysisStepResult>
        projectEvaluated.stepResult.assignmentTrace.resolvedAssignments.entrySet().any {

        where:
        kind       | setExpr         | expr
        "property" | "ext.foo = 1"   | "foo"
        "property" | "ext.foo = 1"   | "hasProperty('foo')"
        "property" | "ext.foo = 1"   | "property('foo')"
        "property" | "ext.foo = 1"   | "findProperty('foo')"
        "property" | "ext.foo = 1"   | "getProperty('foo')"
        "property" | "ext.foo = 1"   | "properties"
        "method"   | "def foo() { }" | "foo()"