====


Both `${languageLC.raw}-library-conventions` and `${languageLC.raw}-application-conventions` apply the `${languageLC.raw}-common-conventions` plugin *(1)* so that the configuration performed there is shared by library and application projects alike.
Next they apply the `java-library` or `application` plugin respectively *(2)* thus combining our common configuration logic with specifics for a library or application.

            ?: Factory {
                // Find convention
                // Reflective look up to still support plugins that inlined this function once conventions will be removed
                this::class.java.methods.firstOrNull { it.name == "getConvention" }?.invoke(this)?.let { convention ->
                    convention::class.java.getMethod("findPlugin", Class::class.java).invoke(convention, T::class.java)
                }

        /**
         * Retrieves the [$original][$type] convention.
         *
         * @deprecated The concept of conventions is deprecated. Use extensions instead.
         */
        val $targetType.`$kotlinIdentifier`: $type get() =
            $thisConvention.getPluginByName<$type>("$stringLiteral")

        /**
         * Configures the [$original][$type] convention.
         *

│   │   │       ├── myproject.java-conventions.gradle.kts
│   │   │       └── myproject.library-conventions.gradle.kts
...
----
=====
[.multi-language-sample]
=====
.Build logic layout
[source, groovy]
----
├── buildSrc
│   ├── build.gradle
│   ├── settings.gradle
│   ├── src
│   │   ├── main
│   │   │   └── groovy
│   │   │       ├── myproject.java-conventions.gradle

                archiveFileName.convention("something")
            }
        """

        expect: 'convention mapping is ignored'
        configurationCacheRun 'myTask'

        and: 'convention mapping is ignored just the same'
        configurationCacheRun 'myTask'
    }

    def "restores convention mapped task input property explicitly set to null"() {
        given:

Convention properties are properties that are initialized with default values but can be overridden:

====
include::sample[dir="snippets/plugins/greeting/kotlin", files="buildSrc/src/main/kotlin/greetings.gradle.kts[tags=convention]"]
include::sample[dir="snippets/plugins/greeting/groovy", files="buildSrc/src/main/groovy/greetings.gradle[tags=convention]"]
====

import org.gradle.internal.declarativedsl.evaluationSchema.buildEvaluationSchema
import org.gradle.internal.declarativedsl.evaluator.conventions.ConventionDefinition
import org.gradle.internal.declarativedsl.evaluator.conventions.ConventionsConfiguringBlock
import org.gradle.internal.declarativedsl.evaluator.conventions.ConventionsTopLevelReceiver
import org.gradle.internal.declarativedsl.software.softwareTypesConventions

/**
 * Checks is a given ObjectOrigin receiver is a call to the `conventions` function.
 */
internal
fun isConventionsCall(parent: ObjectOrigin.ReceiverOrigin) = parent is ObjectOrigin.AccessAndConfigureReceiver &&
    isTopLevelReceiver(parent.receiver) &&
    (parent as? ObjectOrigin.AccessAndConfigureReceiver)?.function?.simpleName == ConventionsTopLevelReceiver::conventions.name


/**

            // val i
            @Suppress("deprecation")
            verify(project).convention
            @Suppress("deprecation")
            verify(convention).plugins

            // val j
            @Suppress("deprecation")
            verify(project).convention
            @Suppress("deprecation")
            verify(convention).plugins

            // val k
            verify(project).dependencies

/**
 * Marks a Gradle API custom type as supporting conventions.
 *
 * <p>
 * <b>Note:</b> This interface is not intended for implementation by build script or plugin authors.
 * </p>
 *
 * @since 8.7
 */
@Incubating
public interface SupportsConvention {
    /**
     * Unsets this object's explicit value, allowing the convention to be
     * selected when evaluating this object's value.
     *