writeLn(" * <p>");
            writeLn(" * This version was declared in " + sanitizeUnicodeEscapes(context));
        }
        writeLn(" */");
        String methodName = asProvider ? "asProvider" : "get" + toJavaName(leafNodeForAlias(versionAlias));
        writeLn("public Provider<String> " + methodName + "() { return getVersion(\"" + versionAlias + "\"); }");
        writeLn();
    }

        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();

        if(dependencyNotation instanceof ProviderConvertible<?>) {
            return doAddProvider(configuration, ((ProviderConvertible<?>) dependencyNotation).asProvider(), configureAction);
        }
        if (dependencyNotation instanceof Provider<?>) {
            return doAddProvider(configuration, (Provider<?>) dependencyNotation, configureAction);
        }

        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