*/
    Set<String> getClassesToCompile();

    List<File> getModulePath();

    void setModulePath(List<File> modulePath);

    default boolean annotationProcessingConfigured() {
        return !getAnnotationProcessorPath().isEmpty() && !getCompileOptions().getCompilerArgs().contains("-proc:none");
    }

        });

        // Note: here, type decides is artifact added to "build path" (for example during resolution)
        // and "build path" is intermediate data that is used to create actual Java classpath/modulepath
        // but to create those, proper filtering should happen via Type properties.
    }

    @Override
    public void addHandlers(Map<String, ArtifactHandler> handlers) {

echo location of your Java installation. 1>&2

goto fail

:execute
@rem Setup the command line

set CLASSPATH=$classpath
<% if ( mainClassName.startsWith('--module ') ) { %>set MODULE_PATH=$modulePath<% } %>

@rem Execute ${applicationName}

	if pp != p {
		t.Errorf("dec.PackagePath(): got %s want %s", pp, p)
	}
	ppn := dec.PackageName()
	if ppn != pn {
		t.Errorf("dec.PackageName(): got %s want %s", ppn, pn)
	}
	pmp := dec.ModulePath()
	if pmp != mp {
		t.Errorf("dec.ModulePath(): got %s want %s", pmp, mp)
	}
}

func TestMetaDataEncoderDecoder(t *testing.T) {
	// Test encode path.
	pp := "foo/bar/pkg"
	pn := "pkg"
	mp := "barmod"

                executable == expectedExecutable
                javaMajorVersion == expectedJavaVersion
                classpath.collect { new File(it as String) }.containsAll(expectedClasspath)
                modulePath == []
                jvmArgs.contains('-Dkey=value')
                environment.KEY == 'VALUE'
            }
            with(candidateClassFiles, List) {
                size() == 1

	PkgPath string

	// Package name.
	PkgName string

	// Instrumentation granularity: one of "perfunc" or "perblock" (default)
	Granularity string

	// Module path for this package (empty if no go.mod in use)
	ModulePath string

	// Local mode indicates we're doing a coverage build or test of a
	// package selected via local import path, e.g. "./..." or
	// "./foo/bar" as opposed to a non-relative import path. See the

        DEFAULT_JVM_OPTS("defaultJvmOpts"),
        APP_NAME_SYS_PROP("appNameSystemProperty"),
        APP_HOME_REL_PATH("appHomeRelativePath"),
        CLASSPATH("classpath"),
        MODULE_PATH("modulePath");

        private final String key;

        ScriptBindingParameter(String key) {
            this.key = key;
        }

        public String getKey() {
            return key;
        }

// the one you can actually download.
type toolchainRepo struct {
	path string // either "go" or "toolchain"
	repo Repo   // underlying DL repo
}

func (r *toolchainRepo) ModulePath() string {
	return r.path
}

func (r *toolchainRepo) Versions(ctx context.Context, prefix string) (*Versions, error) {
	// Read DL repo list and convert to "go" or "toolchain" version list.