implementation.getDependencies().add(getDependencyHandler().create(notation));
    }

    @Override
    public void implementation(Object notation, Action<? super ExternalModuleDependency> action) {
        ExternalModuleDependency dependency = (ExternalModuleDependency) getDependencyHandler().create(notation);
        action.execute(dependency);
        implementation.getDependencies().add(dependency);
    }

        }.get(ObjectFactory)

        dependencies = of.newInstance(JvmComponentDependencies)
    }

    def "String notation is supported"() {
        def example = Mock(ExternalModuleDependency)
        def example2 = Mock(ExternalModuleDependency)

        when:
        dependencies {
            implementation "com.example:example:1.0"
            implementation("com.example:example:2.0") {

        // Because it's a Provider, this isn't called until evaluation
        verify(dependency, never()).exclude(mapOf("module" to "com.google.guava"))
    }

    @Test
    fun `can use a provider convertible for the dependency declaration`() {
        val dependency = mock<ExternalModuleDependency>()
        val dependencies = newDependencyHandlerMock()

     *
     * @see [DependencyHandler.add]
     */
    inline fun DependencyHandler.classpath(
        dependencyNotation: String,
        dependencyConfiguration: ExternalModuleDependency.() -> Unit
    ): ExternalModuleDependency = add(CLASSPATH_CONFIGURATION, dependencyNotation, dependencyConfiguration)

    /**
     * Adds a dependency to the script classpath.
     *

    @Override
    public ExternalModuleDependency create(CharSequence dependencyNotation) {
        ExternalModuleDependency dependency = dependencyNotationParser.getStringNotationParser().parseNotation(dependencyNotation.toString());
        injectServices(dependency);
        return dependency;
    }

    @Override

    }

    /**
     * Create an {@link ExternalModuleDependency} from the given notation.
     *
     * @param dependencyNotation dependency to add
     * @return the new dependency
     * @see DependencyFactory#create(CharSequence) Valid dependency notation for this method
     */
    default ExternalModuleDependency module(CharSequence dependencyNotation) {

    /**
     * Create an {@link ExternalModuleDependency} from the given notation and modifies it to select the variant of the given module as described in {@link #modify(ModuleDependency)}.
     *
     * @param dependencyNotation the dependency notation
     * @return the modified dependency
     * @see DependencyFactory#create(CharSequence)
     */
    public final ExternalModuleDependency modify(CharSequence dependencyNotation) {

import org.gradle.api.Action
import org.gradle.api.artifacts.Configuration
import org.gradle.api.artifacts.Dependency
import org.gradle.api.artifacts.DependencySet
import org.gradle.api.artifacts.ExternalModuleDependency
import org.gradle.api.artifacts.dsl.DependencyHandler
import org.gradle.api.internal.artifacts.configurations.RoleBasedConfigurationContainerInternal
import spock.lang.Specification

package org.gradle.kotlin.dsl

import org.gradle.api.Action
import org.gradle.api.Incubating
import org.gradle.api.artifacts.Dependency
import org.gradle.api.artifacts.DependencyConstraint
import org.gradle.api.artifacts.ExternalModuleDependency
import org.gradle.api.artifacts.FileCollectionDependency
import org.gradle.api.artifacts.MinimalExternalModuleDependency
import org.gradle.api.artifacts.ModuleDependency
import org.gradle.api.artifacts.dsl.Dependencies

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.language;

import org.gradle.api.Action;
import org.gradle.api.artifacts.ExternalModuleDependency;

/**
 * Allows the implementation dependencies of a component to be specified.
 *
 * @since 4.6
 */
public interface ComponentDependencies {
    /**