}
        return dynamicObject;
    }

    @Override
    @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()

 * @see org.gradle.api.plugins.ExtensionAware
 */
@Deprecated
public interface HasConvention {
    org.gradle.api.plugins.Convention getConvention();

        conventionAware.map("list1", TestUtil.toClosure("{ convention, object -> [convention, object] }"));
        assertThat(conventionAware.getConventionValue(null, "list1", false), equalTo((Object) toList(conventionAware.getConvention(), testTask)));
    }

    @Test
    public void canMapPropertiesUsingCallable() {

    @SuppressWarnings("deprecation")
    public ConventionMapping getConventionMapping() {
        if (conventionMapping == null) {
            org.gradle.api.plugins.Convention convention = DeprecationLogger.whileDisabled(this::getConvention);
            conventionMapping = new ConventionAwareHelper(this, convention);
        }
        return conventionMapping;
    }

            getBuildDirectory() >> projectDirProperty.fileValue(new File(testRootDir, "build"))
            getProjectDirectory() >> projectDirProperty.fileValue(testRootDir).get()
        }
        getConvention() >> Stub(Convention) {
            findPlugin(_) >> null
        }
        getExtensions() >> Stub(ExtensionContainerInternal) {
            getByType(JavaPluginExtension) >> Mock(JavaPluginExtension)
        }

                // 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)

        DeprecationLogger.whileDisabled(new Runnable() {
            @Override
            @SuppressWarnings("deprecation")
            public void run() {
                project.getConvention().getPlugins().put("projectReports", convention);
            }
        });

        project.getTasks().register(TASK_REPORT, TaskReportTask.class, taskReportTask -> {

        BasePluginConvention convention = project.getObjects().newInstance(org.gradle.api.plugins.internal.DefaultBasePluginConvention.class, baseExtension);
        DeprecationLogger.whileDisabled(() -> {
            project.getConvention().getPlugins().put("base", new NaggingBasePluginConvention(convention));
        });
    }

    private void configureExtension(Project project, BasePluginExtension extension) {

        final WarPluginConvention pluginConvention = objectFactory.newInstance(org.gradle.api.plugins.internal.DefaultWarPluginConvention.class, project);
        DeprecationLogger.whileDisabled(() -> project.getConvention().getPlugins().put("war", pluginConvention));
        return pluginConvention;
    }

    /**
     * This method is intended for internal use and should not be called.
     *

            if (extensible) {
                // GENERATE public Convention getConvention() { return getAsDynamicObject().getConvention(); }
                addGetter("getConvention", CONVENTION_TYPE, RETURN_CONVENTION, methodVisitor -> new MethodVisitorScope(methodVisitor) {{
                    // GENERATE ((MixInExtensibleDynamicObject)getAsDynamicObject()).getConvention()
                    _ALOAD(0);