// sort advances in depth. Take the following cfg as an example, regardless of other factors.
		//           b1
		//         0/ \1
		//        b2   b3
		// Traverse b.Succs in order, the right child node b3 will be scheduled immediately after
		// b1, traverse b.Succs in reverse order, the left child node b2 will be scheduled
		// immediately after b1. The test results show that reverse traversal performs a little
		// better.

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

// This file implements syntax tree walking.

package syntax

import "fmt"

// Inspect traverses an AST in pre-order: it starts by calling f(root);
// root must not be nil. If f returns true, Inspect invokes f recursively
// for each of the non-nil children of root, followed by a call of f(nil).
//

      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.

	// TrackUnknownFieldPaths determines whether or not unknown field
	// paths should be stored or not.
	TrackUnknownFieldPaths bool
	// ParentPath builds the path to unknown fields as the object
	// is recursively traversed.
	ParentPath []string
	// UnknownFieldPaths is the list of all unknown fields identified.
	UnknownFieldPaths []string
}

// RecordUnknownFields adds a path to an unknown field to the

         * 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

// a given request has been delegated to an aggregated API
// server. No-op when priority and fairness is disabled.
func RequestDelegated(ctx context.Context) {
	// The watch initialization signal doesn't traverse request
	// boundaries, so we generously fire it as soon as we know
	// that the request won't be serviced locally. Safe to call
	// for non-watch requests.
	WatchInitialized(ctx)
}