bool IsConstantOrNone(Operation* op) {
  return (op->getNumResults() == 1 &&
          mlir::isa<NoneType>(op->getResult(0).getType())) ||
         matchPattern(op, m_Constant()) || isa<QConstOp>(op);
}

// Pre-order traverse, adding results and BlockArgs to `been_defined` and
// collecting operands not contained within `been_defined`. If we encounter an
// operand that references a Value that has been defined (and added to

	Schema common.Schema

	// Array of field names and indexes to traverse to get to the value
	KeyPath []interface{}

	// Root object to traverse from
	RootObject    interface{}
	RootOldObject interface{}
}

func (c TestCase) Run() error {
	// Create the correlated object
	correlatedObject := common.NewCorrelatedObject(c.RootObject, c.RootOldObject, c.Schema)

	// Traverse the correlated object
	var err error

 * Nested iterables and maps can be further nested, i.e. {@code Map<String, Iterable<Iterable<String>>>} is supported.
 * Nested {@link Provider}s are unpacked, and the provided type is traversed transparently.
 */
public interface TypeMetadataWalker<T, V extends TypeMetadataWalker.TypeMetadataVisitor<T>> {

    /**
     * A factory method for a walker that can visit the property hierarchy of an instance.
     *

//
// Analyzer names need not be unique, though this may be confusing.
func Validate(analyzers []*Analyzer) error {
	// Map each fact type to its sole generating analyzer.
	factTypes := make(map[reflect.Type]*Analyzer)

	// Traverse the Requires graph, depth first.
	const (
		white = iota
		grey
		black
		finished
	)
	color := make(map[*Analyzer]uint8)
	var visit func(a *Analyzer) error
	visit = func(a *Analyzer) error {

            throw new MetadataGraphTransformationException(e);
        }
    }

    // ===================================================================================================
    /**
     * Helper class to traverse graph. Required to make the containing method thread-safe
     * and yet use class level data to lessen stack usage in recursion
     */
    private class ClasspathGraphVisitor {
        MetadataGraph graph;

// The only possible returned error is [path.ErrBadPattern], reporting that
// the pattern is malformed.
//
// If fs implements [GlobFS], Glob calls fs.Glob.
// Otherwise, Glob uses [ReadDir] to traverse the directory tree
// and look for matches for the pattern.
func Glob(fsys FS, pattern string) (matches []string, err error) {
	return globWithLimit(fsys, pattern, 0)
}

                                  OpBuilder* builder) {
  Region* cluster_region = &cluster.getBody();
  llvm::SmallSetVector<Operation*, 4> head_outside_compiled_ops;

  // Traverse the graph in topological order to find all outside compiled ops
  // at head of TPU computation or unary ops that are only used by other outside
  // compiled ops.
  auto cluster_ops = cluster.GetBody().without_terminator();

  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /
    filters:
    - type: ResponseHeaderModifier
      responseHeaderModifier:
        add:
        - name: traversed-waypoint
          value: {{.Service}}-gateway
    backendRefs:
    - name: {{.Service}}
      port: {{.Port}}
      `

			t.ConfigKube().
				New().
				Eval(
					apps.Namespace.Name(),

            }
            dest.addAll(classPath);
        } finally {
            lock.unlock();
        }
    }

    /**
     * Locates the classpath required by the given target class. Traverses the dependency graph of classes used by the specified class and collects the result in the given collection.
     */
    private void find(Class<?> target, Collection<Class<?>> visited, Collection<URI> dest) {

import com.google.common.annotations.GwtIncompatible;
import javax.annotation.CheckForNull;

/**
 * Implementation of {@code Entry} for {@link ImmutableMap} that adds extra methods to traverse hash
 * buckets for the key and the value. This allows reuse in {@link RegularImmutableMap} and {@link
 * RegularImmutableBiMap}, which don't have to recopy the entries created by their {@code Builder}
 * implementations.
 *