* @param convention the new convention
     * @return the given value, if this value state is not explicit, otherwise the new convention value
     */
    public abstract S applyConvention(S value, S convention);

    /**
     * Marks this value state as being non-explicit. Returns the convention, if any.
     */
    public abstract S implicitValue(S convention);

    public abstract S implicitValue();

    }
}
// end::closure[]

tasks.register("conventions") {
    val objects = objects
    doLast {
        // tag::conventions[]
        val sourceDirs = objects.fileCollection().convention("src")
        sourceDirs.from("src2")
        val sourceDirNames = sourceDirs.map { it.name }
        println("Source dirs: $sourceDirNames") // [src, src2]
        // end::conventions[]
    }
}

tasks.register("usage") {

@Suppress("deprecation")
fun conventionPluginByName(convention: org.gradle.api.plugins.Convention, name: String): Any =
    convention.plugins[name] ?: throw IllegalStateException("A convention named '$name' could not be found.")


@Suppress("deprecation")
fun conventionOf(target: Any): org.gradle.api.plugins.Convention = when (target) {
    is Project -> DeprecationLogger.whileDisabled(Factory { target.convention })!!

    fun findConventions(softwareTypeName: String): SoftwareTypeConventionResolutionResults?
}


/**
 * Transformation logic for the kinds of resolution results that appear in conventions.
 * For any of the supported result records, supports replacing the `conventions { ... }` receiver in it with
 * the given [targetBaseReceiver].
 */
private
class ConventionTransformer(
    private val targetBaseReceiver: ObjectOrigin.ReceiverOrigin
) {

    @Deprecated
    public org.gradle.api.plugins.Convention getConvention() {
// TODO nag once KGP doesn't register conventions anymore
//        DeprecationLogger.deprecateType(org.gradle.api.internal.HasConvention.class)
//            .willBeRemovedInGradle9()
//            .withUpgradeGuideSection(8, "deprecated_access_to_conventions")
//            .nagUser();
        if (convention == null) {

    }

    public ExtensibleDynamicObject(Object delegate, AbstractDynamicObject dynamicDelegate, org.gradle.api.plugins.Convention convention) {
        this.dynamicDelegate = dynamicDelegate;
        this.convention = convention;
        this.extraPropertiesDynamicObject = new ExtraPropertiesDynamicObjectAdapter(delegate.getClass(), convention.getExtraProperties());

        updateDelegates();
    }

                switch (value.getMaximumNumberOfParameters()) {
                    case 0:
                        return value.call();
                    case 1:
                        return value.call(convention);
                    default:
                        return value.call(convention, conventionAwareObject);
                }
            }
        });

import static org.junit.Assume.assumeFalse
import static org.junit.Assume.assumeTrue

@TargetVersions("5.0+")
class ProjectTheExtensionCrossVersionSpec extends CrossVersionIntegrationSpec {

    def "can access extensions and conventions with current Gradle version from plugin built with Gradle 5.0+"() {

        def isFlaky = OperatingSystem.current().isWindows() &&
            previous.version >= GradleVersion.version("6.5") &&

    }

    def "shallow copy copies the convention if the property has no explicit value"() {
        given:
        def property = propertyWithNoValue()
        property.convention(someValue())

        expect:
        property.shallowCopy().orNull == someValue()
    }

    def "shallow copy is not affected by changes to original convention"() {
        given:
        def property = propertyWithNoValue()

  echo "!!! Some package aliases break go conventions."
  echo "To fix these errors, do not use capitalized or underlined characters"
  echo "in pkg aliases. Refer to https://blog.golang.org/package-names for more info."
  exit 1