return e.getKey();
                                }

                                @Override
                                public TypeOf<?> getPublicType() {
                                    // TODO: This returns the wrong public type for domain objects
                                    // created with the eager APIs or added directly to the container.

        this.project = project;
        applicationDistribution = project.copySpec();
    }

    @Override
    @SuppressWarnings("deprecation")
    public TypeOf<?> getPublicType() {
        return typeOf(org.gradle.api.plugins.ApplicationPluginConvention.class);
    }

    @Override
    public String getApplicationName() {
        logDeprecation();
        return applicationName;
    }

                    on { elements }.thenReturn(listOf<ExtensionSchema>(object : ExtensionSchema {
                        override fun getName(): String = "myExtension"
                        override fun getPublicType(): TypeOf<*> = TypeOf.typeOf(MyExtension::class.java)
                    }))
                }
                mock<ExtensionContainer> {
                    on { extensionsSchema }.thenReturn(extensionsSchemaMock)

class ProjectSchemaNamedDomainObjectSchema(
    private val objectName: String,
    private val objectPublicType: TypeOf<*>
) : NamedDomainObjectSchema {

    override fun getName() = objectName

    override fun getPublicType() = objectPublicType
}


private
fun sourceSetsOf(project: Project) =
    project.extensions.findByName("sourceSets") as? SourceSetContainer


private

        checkExtensionIsNotReassigned(name);
        add(name, value);
    }

    private void addWithDefaultPublicType(String name, Object extension) {
        add(new DslObject(extension).getPublicType(), name, extension);
    }

    private <T> T instantiate(Class<? extends T> instanceType, String name, Object[] constructionArguments) {

        return withNoImplementsMissing;
    }

    @Override
    public String getDisplayName() {
        return bean.toString();
    }

    @Nullable
    @Override
    public Class<?> getPublicType() {
        return publicType != null ? publicType : bean.getClass();
    }

    @Override
    public boolean hasUsefulDisplayName() {
        if (bean instanceof ModelObject) {

            import org.gradle.kotlin.dsl.*

            interface MyConvention

            internal
            class MyPrivateConventionImpl : MyConvention, HasPublicType {
                override fun getPublicType() = typeOf<MyConvention>()
            }
            """
        )

        assertThat(
            build("help").output,
            containsString("Type of `myConvention` receiver is MyConvention")

                            public String getName() {
                                return name;
                            }

                            @Override
                            public TypeOf<?> getPublicType() {
                                return TypeOf.typeOf(getType());
                            }
                        };
                    }
                });
            }
        };
    }

Method <org.gradle.platform.base.binary.BaseBinarySpec.getProjectScopedName()> does not have raw return type assignable to org.gradle.api.provider.Provider in (BaseBinarySpec.java:0)
Method <org.gradle.platform.base.binary.BaseBinarySpec.getPublicType()> does not have raw return type assignable to org.gradle.api.provider.Provider in (BaseBinarySpec.java:0)