publication.setModule(pluginId + PLUGIN_MARKER_SUFFIX);

        Provider<String> organisation = getProviderFactory().provider(mainPublication::getOrganisation);
        Provider<String> module = getProviderFactory().provider(mainPublication::getModule);
        Provider<String> revision = getProviderFactory().provider(mainPublication::getRevision);

        publication.descriptor(new Action<IvyModuleDescriptorSpec>() {

        publication.setGroupId(pluginId);

        Provider<String> groupProvider = getProviderFactory().provider(coordinates::getGroupId);
        Provider<String> artifactIdProvider = getProviderFactory().provider(coordinates::getArtifactId);
        Provider<String> versionProvider = getProviderFactory().provider(coordinates::getVersion);
        publication.getPom().withXml(new Action<XmlProvider>() {
            @Override

    @Override
    public String getName() {
        return name;
    }

    @Inject
    public abstract ObjectFactory getObjectFactory();

    @Inject
    public abstract ProviderFactory getProviderFactory();

    @Inject
    public abstract InstantiatorFactory getInstantiatorFactory();

    @Inject
    public abstract ServiceRegistry getParentServices();

    @Override

                public String getText() {
                    return text.get();
                }

                @Internal
                public Boolean getRenderText() {
                    return getProviderFactory().provider(new Callable<Boolean>() {
                        @Override
                        public Boolean call() throws Exception {
                            return $renderText;
                        }

        execResult = objectFactory.property(ExecResult.class);
        javaExecSpec = objectFactory.newInstance(DefaultJavaExecSpec.class);

        Provider<Iterable<String>> jvmArgumentsConvention = getProviderFactory().provider(this::jvmArgsConventionValue);

        jvmArguments = objectFactory.listProperty(String.class).convention(jvmArgumentsConvention);

        javaExecSpec.getMainClass().convention(mainClass);

    }

    @Inject
    protected StyledTextOutputFactory getTextOutputFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject
    protected ProviderFactory getProviderFactory() {
        throw new UnsupportedOperationException();
    }

    @Inject
    protected abstract ToolchainConfiguration getToolchainConfiguration();

        modularity = objectFactory.newInstance(DefaultModularitySpec.class);
        JavaToolchainService javaToolchainService = getJavaToolchainService();
        Provider<JavaCompiler> javaCompilerConvention = getProviderFactory()
            .provider(() -> JavaCompileExecutableUtils.getExecutableOverrideToolchainSpec(this, objectFactory))
            .flatMap(javaToolchainService::compilerFor)

        this.modularity = objectFactory.newInstance(DefaultModularitySpec.class);
        JavaToolchainService javaToolchainService = getJavaToolchainService();
        Provider<JavadocTool> javadocToolConvention = getProviderFactory()
            .provider(() -> JavadocExecutableUtils.getExecutableOverrideToolchainSpec(this, objectFactory))
            .flatMap(javaToolchainService::javadocToolFor)

    def "emits deprecation warning when convention mapping is used with Provider"() {
        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Inject abstract ProviderFactory getProviderFactory()

                @Internal abstract Property<String> getOther()

                @Internal Provider<String> getFoo() {
                    return other;
                }

                @TaskAction

    String getEffectivePackageName(BuildInitializer initializer) {
        String packageName = this.packageName;
        if (initializer.supportsPackage()) {
            if (packageName == null) {
                return getProviderFactory().gradleProperty(SOURCE_PACKAGE_PROPERTY).getOrElse(SOURCE_PACKAGE_DEFAULT);
            }
        } else if (!isNullOrEmpty(packageName)) {