VALUE_PARAMETER name:p1 index:1 type:<root>.Foo
        EXPRESSION_BODY
          BLOCK type=kotlin.Int origin=null
            CALL 'public final fun plus (other: kotlin.Int): kotlin.Int [operator] declared in kotlin.Int' type=kotlin.Int origin=PLUS
              $this: CALL 'public open fun <get-length> (): kotlin.Int declared in kotlin.String' type=kotlin.Int origin=GET_PROPERTY

 *   //   extensionReceiver: null
 *   // }
 *   // accessType: OpAssign {
 *   //   kind: PLUS
 *   //   operand: "b"
 *   //   operationSymbol: String?.plus()
 *   // }
 * }
 * ```
 * Such a call always involve both calls to `get` and `set` functions. With the example above, a call to `String?.plus` is sandwiched
 * between `get` and `set` call to compute the new value passed to `set`.
 *

import org.gradle.declarative.dsl.model.annotations.Restricted
import org.gradle.internal.declarativedsl.demo.reflection.reflect
import org.gradle.internal.declarativedsl.schemaBuilder.plus
import org.gradle.internal.declarativedsl.schemaBuilder.schemaFromTypes
import org.gradle.internal.declarativedsl.schemaBuilder.treatInterfaceAsConfigureLambda
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

            }
        }
    }

    /**
     * Returns the next group of elements after removing them from the queue.
     *
     * The group contains the most recently pushed element plus all
     * elements superseded by it ordered from most recent to least recent.
     */
    fun nextGroup(timeoutMillis: Long = pollTimeoutMillis): List<T> {
        lock.withLock {
            if (q.isNotEmpty()) {

        val value: Any?
            get() = lazyValue.value
    }
}


operator fun ConfigureLambdaHandler.plus(other: ConfigureLambdaHandler) =
    CompositeConfigureLambdas(buildList {
        when (this@plus) {
            is CompositeConfigureLambdas -> addAll(implementations)
            else -> add(this@plus)
        }
        when (other) {
            is CompositeConfigureLambdas -> addAll(other.implementations)

        return gson.toJson(subprojects) + '\n'
    }

    private
    fun generateSubprojectsDirectories(): List<File> {
        val subprojectRoots = platformsFolder.asFile.listFiles(File::isDirectory).plus(subprojectsFolder.asFile).plus(testingFolder.asFile)
        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {

     * @return a new supplier that produces a collection that contains the
     * same elements as this supplier, plus the elements obtained via the given <code>added</code> collector
     */
    CollectionSupplier<T, C> plus(Collector<T> added);

    ExecutionTimeValue<? extends C> calculateExecutionTimeValue();

    /**

        }
    }
}


operator fun PropertyExtractor.plus(other: PropertyExtractor): CompositePropertyExtractor = CompositePropertyExtractor(buildList {
    fun include(propertyExtractor: PropertyExtractor) = when (propertyExtractor) {
        is CompositePropertyExtractor -> addAll(propertyExtractor.extractors)
        else -> add(propertyExtractor)
    }
    include(this@plus)
    include(other)
})

constraints.AssertFalse.message = {item} doit être faux.
constraints.AssertTrue.message  = {item} doit être vrai.
constraints.DecimalMax.message  = {item} doit être plus petit que ${inclusive == true ? 'or equal to ' : ''}{value}.
constraints.DecimalMin.message  = {item} doit être plus grand que  ${inclusive == true ? 'or equal to ' : ''}{value}.

package org.gradle.model.internal.manage.schema;

/**
 * The schema for a fully managed element. This means that we have control over all aspects of the lifecycle of the element: the actual
 * implementation of the element, plus the implementation and instantiation of views for the instance.
 */
public interface ManagedImplSchema<T> extends ModelSchema<T> {