List<String> submodulePaths = new ArrayList<>();
        try {
            SubmoduleWalk walker = SubmoduleWalk.forIndex(git.getRepository());
            try {
                while (walker.next()) {
                    Repository submodule = walker.getRepository();
                    try {
                        submodulePaths.add(walker.getPath());
                        Git.wrap(submodule).pull().call();

			orig := &def.Schema
			if ret := pruneEnums(orig); ret != orig {
				def.Schema = *ret
				defs[gvk] = def
			}
		}
	}
}

func pruneEnums(schema *spec.Schema) *spec.Schema {
	walker := schemamutation.Walker{
		SchemaCallback: func(schema *spec.Schema) *spec.Schema {
			orig := schema
			clone := func() {
				if orig == schema { // if schema has not been mutated yet
					schema = new(spec.Schema)

    }

    public Map<String, String> getAttributes() {
        return attributes;
    }

    public FileCollection resolve() {
        try {
            walker.add(queue);
            return new UnionFileCollection(taskDependencyFactory, walker.findValues());
        } finally {
            queue.clear();
        }
    }

    /**

        GetInputFilesVisitor visitor = new GetInputFilesVisitor(task.toString(), fileCollectionFactory)
        def walker = task.getServices().get(PropertyWalker)
        TaskPropertyUtils.visitProperties(walker, task, visitor)
        return new CompositeFileCollection() {
            @Override
            String getDisplayName() {
                return task + " input files"

        def visitor = new GetInputPropertiesVisitor()
        TaskPropertyUtils.visitProperties(walker, task, visitor)
        return visitor.properties.collectEntries { [it.propertyName, InputParameterUtils.prepareInputParameterValue(it.value)] }
    }

    def inputFileProperties() {
        def inputFiles = [:]
        TaskPropertyUtils.visitProperties(walker, task, new PropertyVisitor() {
            @Override
            void visitInputFileProperty(

        files = args.filenames
    else:
        for root, dirs, walkfiles in os.walk(args.rootdir):
            # don't visit certain dirs. This is just a performance improvement
            # as we would prune these later in normalize_files(). But doing it
            # cuts down the amount of filesystem walking we do and cuts down
            # the size of the file list
            for dname in skipped_names:

        fileTree.visit(fileVisitor)
        visited
    }

    @Override
    protected List<String> walkDirForPaths(DirectorySnapshotter walker, File rootDir, PatternSet patternSet) {
        def snapshot = walker.snapshot(rootDir.absolutePath, directoryWalkerPredicate(patternSet), [:], completeSnapshotConsumer)
        return SnapshotVisitorUtil.getAbsolutePaths(snapshot)
    }

// compile

// Copyright 2014 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Issue 8076. nilwalkfwd walked forward forever
// on the instruction loop following the dereference.

package main

func main() {
	_ = *(*int)(nil)
L:
	_ = 0
	goto L

	var stack []int
	seen := make([]bool, len(check.mono.vertices))

	// We have a path that contains a cycle and ends at v, but v may
	// only be reachable from the cycle, not on the cycle itself. We
	// start by walking backwards along the path until we find a vertex
	// that appears twice.
	for !seen[v] {
		stack = append(stack, v)
		seen[v] = true
		v = check.mono.edges[check.mono.vertices[v].pre].src
	}

            }
        }
    }

    private static void updateSubModules(Git git) throws IOException, GitAPIException {
        try (SubmoduleWalk walker = SubmoduleWalk.forIndex(git.getRepository())) {
            while (walker.next()) {
                try (Repository submodule = walker.getRepository()) {
                    if (submodule != null) {
                        Git submoduleGit = Git.wrap(submodule);