}

    /**
     * A recursive function that traverses the dependency graph of a given module and acts on each node and edge encountered.
     *
     * @param start A ResolvedComponentResult node, which represents the entry point into the sub-section of the dependency
     * graph to be traversed
     * @param moduleAction an action to be performed on each node (module) in the graph

import java.util.List;

public interface ConfigurationResolver {

    /**
     * Traverses enough of the graph to calculate the build dependencies of the given resolve context. All failures are packaged in the result.
     */
    ResolverResults resolveBuildDependencies(ResolveContext configuration);

    /**
     * Traverses the full dependency graph of the given resolve context. All failures are packaged in the result.
     */

  const CallGraph call_graph(module);
  // symbol_table caches callees in the CallGraph.
  SymbolTableCollection symbol_table;
  // List pending nodes to traverse with their root TPU cluster.
  llvm::SmallVector<std::pair<CallGraphNode*, tf_device::ClusterOp>>
      pending_call_nodes;
  // Cache the host device for each TPU cluster.

// We can redirect p to s directly.
//
// The implementation here borrows the framework of the prove pass.
//
//	1, Traverse all blocks of function f to find If blocks.
//	2,   For any If block b, traverse all its predecessors to find If blocks.
//	3,     For any If block predecessor p, update relationship p->b.
//	4,     Traverse all successors of b.
//	5,       For any successor s of b, try to update relationship b->s, if a

				f(ev.node, false, stack)
			}
			stack = stack[:len(stack)-1]
		}
		i++
	}
}

// traverse builds the table of events representing a traversal.
func traverse(files []*ast.File) []event {
	// Preallocate approximate number of events
	// based on source file extent.
	// This makes traverse faster by 4x (!).
	var extent int
	for _, f := range files {
		extent += int(f.End() - f.Pos())
	}

// 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.

// PR61244: Type descriptors expressions were not traversed, causing an ICE
// in gccgo when producing the backend representation.
// This is a reduction of a program reported by GoSmith.

package main

const a = 0

func main() {
	switch i := (interface{})(a); i.(type) {

// 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 7590: gccgo incorrectly traverses nested composite literals.

package p

type S struct {
	F int
}

var M = map[string]S{
	"a": { F: 1 },
}

var P = M["a"]

 *     <li>EXECUTE access: 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.</li>
 * </ul>
 *
 * @since 8.3
 */
public interface UserClassFilePermissions {

    /**

}

type PatchMetaFromOpenAPIV3 struct {
	// SchemaList is required to resolve OpenAPI V3 references
	SchemaList map[string]*spec.Schema
	Schema     *spec.Schema
}

func (s PatchMetaFromOpenAPIV3) traverse(key string) (PatchMetaFromOpenAPIV3, error) {
	if s.Schema == nil {
		return PatchMetaFromOpenAPIV3{}, nil
	}
	if len(s.Schema.Properties) == 0 {

		*v, err = convertNumber(v2)
	case map[string]interface{}:
		err = ConvertMapNumbers(v2, depth+1)
	case []interface{}:
		err = ConvertSliceNumbers(v2, depth+1)
	}
	return err
}

// ConvertMapNumbers traverses the map, converting any json.Number values to int64 or float64.
// values which are map[string]interface{} or []interface{} are recursively visited
func ConvertMapNumbers(m map[string]interface{}, depth int) error {