if (symref.getValue() != func.getName()) continue;
      op->setAttr(attr.getName(),
                  FlatSymbolRefAttr::get(op->getContext(), cloned.getName()));
      break;
    }
  }

  // Traverse results backward so that indices to be deleted stay unchanged.
  for (OpResult result : llvm::reverse(op->getResults())) {
    if (!result.use_empty()) continue;
    int result_idx = result.getResultNumber();

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// The init cycle diagnosis used to take exponential time
// to traverse the call graph paths. This test case takes
// at least two minutes on a modern laptop with the bug
// and runs in a fraction of a second without it.
// 10 seconds (-t 10 above) should be plenty if the code is working.

         * No null keys or values.
         * Never empty.
         */
        @Nullable
        Map<String, byte[]> getInputValueHashesBytes();

        /**
         * Traverses the input properties that are file types (e.g. File, FileCollection, FileTree, List of File).
         * <p>
         * If there are no input file properties, visitor will not be called at all.
         * <p>

     * <p>
     * Execute access grant the capability to run a file as a program; executing a directory
     * doesn't really make sense, it's more like a traverse permission; for example, a user
     * must have 'execute' access to the 'bin' directory in order to execute the 'ls' or 'cd' commands.
     */
    void setExecute(boolean execute);

     * Listener triggered when a spec is added to the hierarchy.
     */
    interface CopySpecListener {
        void childSpecAdded(CopySpecAddress path, CopySpecInternal spec);
    }

    /**
     * A visitor to traverse the spec hierarchy.
     */
    interface CopySpecVisitor {
        void visit(CopySpecAddress address, CopySpecInternal spec);
    }

    /**
     * The address of a spec relative to its parent.
     */

	for _, node := range list {
		Walk(v, node)
	}
}

// TODO(gri): Investigate if providing a closure to Walk leads to
// simpler use (and may help eliminate Inspect in turn).

// Walk traverses an AST in depth-first order: It starts by calling
// v.Visit(node); node must not be nil. If the visitor w returned by
// v.Visit(node) is not nil, Walk is invoked recursively with visitor

import org.gradle.integtests.fixtures.ToBeFixedForIsolatedProjects

class TaskSelectionIntegrationTest extends AbstractIntegrationSpec {

    @ToBeFixedForIsolatedProjects(because = "subprojects")
    def "given an unqualified name traverse project tree from current project and select all tasks with matching name"() {
        createDirs("a", "b", "a/a", "b/b")
        settingsFile << "include 'a', 'b', 'a:a', 'b:b'"

        buildFile << """

    /**
     * The repository where this artifact has been downloaded from.
     */
    @Nonnull
    Optional<RemoteRepository> getRepository();

    /**
     * Traverses this node and potentially its children using the specified visitor.
     *
     * @param visitor the visitor to call back, must not be {@code null}

import java.util.List;
import java.util.Set;

public interface ModelNode {

    boolean hasLink(String name);

    boolean hasLink(String name, ModelType<?> type);

    // Note: order is crucial here. Nodes are traversed through these states in the order defined below
    enum State {
        Registered(true), // Initial state. Only path and some projections are known here
        Discovered(true), // All projections are defined

		// TODO: support SEH on other architectures.
		return fmt.Errorf("unsupported architecture for SEH: %v", arch.Family)
	}
}

func processSEHAMD64(ldr *loader.Loader, pdata sym.LoaderSym) error {
	// The following loop traverses a list of pdata entries,
	// each entry being 3 relocations long. The first relocation
	// is a pointer to the function symbol to which the pdata entry
	// corresponds. The third relocation is a pointer to the