type ArgumentError struct {
	Index int
	Err   error
}

func (e *ArgumentError) Error() string { return e.Err.Error() }
func (e *ArgumentError) Unwrap() error { return e.Err }

// An Importer resolves import paths to Packages.
//
// CAUTION: This interface does not support the import of locally
// vendored packages. See https://golang.org/s/go15vendor.
// If possible, external implementations should implement [ImporterFrom].

            .withTasks("checkSystemPropertyGradleUserHomeHasPrecedence")
            .run()
    }

    @Requires([UnitTestPreconditions.Symlinks, IntegTestPreconditions.NotEmbeddedExecutor])
    def "resolves links when determining home directory"() {
        when:
        def script = file('bin/my app')
        script.parentFile.createDir()
        script.createLink(distribution.gradleHomeDir.file('bin/gradle'))

        succeeds(":resolve")
    }

    @ToBeFixedForConfigurationCache(because = "uses Configuration API at runtime")
    def "exception when non-gradle thread resolves dependency graph"() {
        mavenRepo.module("test", "test-jar", "1.0").publish()

        settingsFile << """
            rootProject.name = "foo"
        """

        buildFile << """

 */

// resolveNameOff resolves a name offset from a base pointer.
// The (*rtype).nameOff method is a convenience wrapper for this function.
// Implemented in the runtime package.
//
//go:noescape
func resolveNameOff(ptrInModule unsafe.Pointer, off int32) unsafe.Pointer

// resolveTypeOff resolves an *rtype offset from a base type.

    /**
     * Generates a `repositories` block pointing to the standard maven repo fixture.
     *
     * This is often required for running with configuration cache enabled, as
     * configuration cache eagerly resolves dependencies when storing the classpath.
     */
    protected String mavenTestRepository(GradleDsl dsl = GROOVY) {
        """
        repositories {

import org.eclipse.aether.version.Version;
import org.eclipse.aether.version.VersionScheme;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Resolves a version for a plugin.
 *
 * @since 3.0
 */
@Named
@Singleton
public class DefaultPluginVersionResolver implements PluginVersionResolver {
    private static final String REPOSITORY_CONTEXT = "plugin";

  // TODO(josh11b, keveman): Make this faster; right now it converts
  // Graph->GraphDef->Graph.  This cleans up the graph (e.g. adds
  // edges from the source and to the sink node, resolves back edges
  // by name), and makes sure the resulting graph is valid.
  Status ToGraph(
      Graph* g, GraphConstructorOptions opts = GraphConstructorOptions{}) const;

import org.eclipse.aether.util.filter.AndDependencyFilter;
import org.eclipse.aether.util.filter.ScopeDependencyFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <p>
 * Resolves dependencies for the artifacts in context of the lifecycle build
 * </p>
 * <strong>NOTE:</strong> This class is not part of any public api and can be changed or deleted without prior notice.
 * @since 3.0
 */
@Named

  // resource instance is suitable. The language is as defined in
  // https://kubernetes.io/docs/reference/using-api/cel/
  //
  // In addition, for each type in NamedResourcesAttributeValue there is a map that
  // resolves to the corresponding value of the instance under evaluation.
  // For example:
  //
  //    attributes.quantity["a"].isGreaterThan(quantity("0")) &&
  //    attributes.stringslice["b"].isSorted()

* implementing the required code yourself in your project
* copying the required code from the library (with attribution!) if it is open source

=== Optimize repository order

When Gradle resolves dependencies, it searches through each repository in the declared order.
To reduce the time spent searching for dependencies, declare the repository hosting