joinTo(this@buildString, separator = "\n  ", prefix = ":\n  ") { property ->
                    val name = property.name

                    @Suppress("UNCHECKED_CAST")
                    val value = (property as KProperty1<Any, *>).get(this@with)?.let {
                        if (className == "KaErrorCallInfo" && name == "candidateCalls") {

** `Property` extends the `Provider` interface.
** The method link:{javadocPath}/org/gradle/api/provider/Property.html#set-T-[Property.set(T)] specifies a value for the property, overwriting whatever value may have been present.

fun x() {
    val xProperty = 10
    fun xFunction() = 11
    typealias xTypealias = 10
    class XClass<XT> {}
    enum class XEnum {
        X_ENUM_ENTRY;

        fun xEnumMember(){}
    }

    class Y <YT> {
        val yProperty = 10
        fun yFunction() = 11
        typealias yTypealias = 10
        class YClass<YTT> {}
        enum class YEnum {
            Y_ENUM_ENTRY;

            fun yEnumMember(){}

        readOnlyBean.someValue.toString() == "<display name> property 'someValue'"
        readOnlyBeanWithMapping.someValue.toString() == "<display name> property 'someValue'"
        finalBeanWithOverloads.getSomeValue().toString() == "<display name> property 'someValue'"
        beanWithOverloads.getSomeValue().toString() == "<display name> property 'someValue'"

    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)