/**
     * {@return the type of path detected}. The return value is {@link JavaPathType#MODULES}
     * if the dependency is a modular JAR file or a directory containing module descriptor(s),
     * or {@link JavaPathType#CLASSES} otherwise. A JAR file without module descriptor but with
     * an "Automatic-Module-Name" manifest attribute is considered modular.
     */
    public JavaPathType getPathType() {

        void expectGetMetadata(String group, String module) {
            String id = "$group:$module"
            server.expectGet("/repo/${group.replace('.', '/')}/$module/metadata.json", files[id])
        }

        @Override
        void expectRefresh(String group, String module) {
            String id = "$group:$module"
            server.expectHead("/repo/${group.replace('.', '/')}/$module/metadata.json", files[id])
        }
    }

# main modules from the build list incorrectly, leading to the workspace
# modules being checked for correct sums. Specifically this would happen when
# the module name sorted after the virtual 'go' version module name because
# it could not get chopped off when we removed the MainModules.Len() modules
# at the beginning of the build list and we would remove the go module instead.

go mod verify

-- go.work --

If module-aware mode is enabled, "go install" runs in the context of the main
module.
-- text --
If the arguments have version suffixes
(like @latest or @v1.0.0), "go install"
builds packages in module-aware mode,
ignoring the go.mod file in the current
directory or any parent directory,
if there is one. This is useful for
installing executables without affecting
the dependencies of the main module.

  <version>1.0</version>
  <packaging>pom</packaging>
  <modules>
    <module>module-2</module>
    <module>module-1</module>
    <module>module-3</module>
  </modules>
  <profiles>
    <profile>
      <id>a</id>
      <properties>
        <b>test-prop</b>
      </properties>
      <modules>
        <module>module-1</module>
        <module>module-4</module>
      </modules>
    </profile>
  </profiles>

        def mod1 = mavenHttpRepo.module("group1", "module1", "1.0").publish()
        def mod2 = mavenHttpRepo.module("group1", "module2", "0.99").dependsOn(mod1).publish()

        buildFile << """
repositories {
    maven { url "${mavenHttpRepo.uri}" }
}
configurations {
    a
    b
}
dependencies {
    a "group1:module1:1.0"
    b "group1:module2:0.99"
}
task a {
    def files = configurations.a

	return &BuildListError{
		Err:   err,
		stack: stack,
	}
}

// Module returns the module where the error occurred. If the module stack
// is empty, this returns a zero value.
func (e *BuildListError) Module() module.Version {
	if len(e.stack) == 0 {
		return module.Version{}
	}
	return e.stack[len(e.stack)-1].m
}

func (e *BuildListError) Error() string {

go mod vendor -e
stderr -count=2 'no required module provides package'
stderr '^go: example.com/untidy imports\n\texample.net/m: module example.net/m provides package example.net/m and is replaced but not required; to add it:\n\tgo get example.net/m@v0.1.0$'
exists vendor/modules.txt
! exists vendor/example.net

go mod edit -require example.net/m@v0.1.0
go mod vendor -e
stderr -count=3 'no required module provides package'
exists vendor/modules.txt

// It also returns the modroot of the module providing the replacement if
// one was found.
func resolveReplacement(m module.Version) module.Version {
	if r := Replacement(m); r.Path != "" {
		return r
	}
	return m
}

func toReplaceMap(replacements []*modfile.Replace) map[module.Version]module.Version {
	replaceMap := make(map[module.Version]module.Version, len(replacements))
	for _, r := range replacements {

		</dependent-module>
		<dependent-module archiveName="api-1.0.jar" deploy-path="/WEB-INF/lib" handle="module:/resource/api/api">
			<dependency-type>uses</dependency-type>
		</dependent-module>
	</wb-module>