//
	// Invariant: Uses[id].Pos() != id.Pos()
	Uses map[*syntax.Name]Object

	// Implicits maps nodes to their implicitly declared objects, if any.
	// The following node and object types may appear:
	//
	//     node               declared object
	//
	//     *syntax.ImportDecl    *PkgName for imports without renames

	//
	// Invariant: Uses[id].Pos() != id.Pos()
	Uses map[*ast.Ident]Object

	// Implicits maps nodes to their implicitly declared objects, if any.
	// The following node and object types may appear:
	//
	//     node               declared object
	//
	//     *ast.ImportSpec    *PkgName for imports without renames

Ideally, the plugin implementation does not need to ask the user for the coordinates of that dependency - it can simply predefine a sensible default version.

Let’s look at an example of a plugin that downloads files containing data for further processing.

  - Variant apiElements:
      - Declares capability org:foo:1.0 which cannot be mapped to Maven'''
        outputContains '''
  - Variant runtimeElements:
      - Declares capability org:bar:1.0 which cannot be mapped to Maven
      - Declares capability org:foo:1.0 which cannot be mapped to Maven'''

Which are the convention plugins we already inspected above.
Furthermore, we add Gradle's plugin portal as repository *(2)*, which gives us access to community plugins.
To use a plugin it needs to be declared as dependency in the `dependencies {}` block.

Apart from the Gradle build files, you can find example ${language.raw} source code and test source code in the corresponding folders.

                        .documentedAt(userManual("validation_problems", "cacheable_transform_cant_use_absolute_sensitivity"))
                        .contextualLabel("is declared to be sensitive to absolute paths")
                        .severity(ERROR)

====

In the example above, Gradle will use the versions resolved on the `runtimeClasspath` for dependencies declared in `api`, which are mapped to the `compile` configuration of Ivy.
Gradle will also use the versions resolved on the `runtimeClasspath` for dependencies declared in `implementation`, which are mapped to the `runtime` configuration of Ivy.

* The configurations in blue, also known as resolvable denoted by \(R), are internal to the component, for its own use

The following configurations are used to declare dependencies:

`testImplementation`::
Used for declaring implementation dependencies for all variants of the test component.
This is where you should declare dependencies of any variants.

If you have such a build failure and the related `afterEvaluate` statement is declared in your build sources then you can simply delete it.
If `afterEvaluate` is declared in a plugin then report the issue to the plugin maintainers.

=== Modifying file collections after values finalized is now an error

* If a `groovy-all(-indy)` Jar is found on `classpath`, that jar will be added to `groovyClasspath`.
* If a `groovy(-indy)` jar is found on `classpath`, and the project has at least one repository declared, a corresponding `groovy(-indy)` repository dependency will be added to `groovyClasspath`.
* Otherwise, execution of the task will fail with a message saying that `groovyClasspath` could not be inferred.