doAddLazy(externalModule.asProvider(), null);
    }

    @Override
    public void add(ProviderConvertible<? extends MinimalExternalModuleDependency> externalModule, Action<? super ExternalModuleDependency> configuration) {
        doAddLazy(externalModule.asProvider(), configuration);
    }

    @Override
    public void add(Dependency dependency) {

 * limitations under the License.
 */

plugins {
    id 'scala'
}

// tag::use_version_asprovider[]
scala {
    zincVersion = libs.versions.zinc.asProvider().get()
}

 * limitations under the License.
 */

plugins {
    scala
}

// tag::use_version_asprovider[]
scala {
    zincVersion = libs.versions.zinc.asProvider().get()
}

 * @since 7.3
 */
@HasInternalProtocol
@NonExtensible
public interface ProviderConvertible<T> {

    /**
     * Returns a {@link Provider} from this object.
     */
    Provider<T> asProvider();

                    return NullPluginDependencySpec
                }

                override fun alias(notation: ProviderConvertible<PluginDependency>): PluginDependencySpec {
                    return alias(notation.asProvider())
                }
            }
        )
    }
}


/**
 * Script template definition for precompiled Kotlin scripts targeting [Project] instances.
 *

 * limitations under the License.
 */

package org.gradle.internal.service;

/**
 * Represents a source of services.
 */
interface ContainsServices {
    ServiceProvider asProvider();

        dependency.module >> DefaultModuleIdentifier.newId("org.foo", "bar")
        dependency.versionConstraint >> new DefaultMutableVersionConstraint("1.0")
        providerConvertible.asProvider() >> provider
        provider.get() >> dependency

        when:
        def v = parser("").parseNotation(providerConvertible)

        then:
        v
        v.group == 'org.foo'

                    return NullPluginDependencySpec
                }

                override fun alias(notation: ProviderConvertible<PluginDependency>): PluginDependencySpec {
                    return alias(notation.asProvider())
                }
            }
        )
    }

    object NullPluginDependencySpec : PluginDependencySpec {
        override fun apply(apply: Boolean) = this

     * @since 8.7
     */
    default Provider<? extends DependencyConstraint> constraint(ProviderConvertible<? extends MinimalExternalModuleDependency> dependencyConstraint) {
        return constraint(dependencyConstraint.asProvider());
    }

    /**
     * Create a {@link DependencyConstraint} from a project.
     *
     * @param project the project
     * @return the new dependency constraint
     * @since 8.7
     */

     */
    public final Provider<? extends MinimalExternalModuleDependency> modify(ProviderConvertible<? extends MinimalExternalModuleDependency> providerConvertibleToDependency) {
        return providerConvertibleToDependency.asProvider().map(this::modify);
    }

    /**