// All operations.
  llvm::DenseSet<Operation*> all_operations;

  // All results of all ops.
  llvm::DenseSet<Value> all_internal_results;
  for (Operation* outer : ops) {
    outer->walk([&](Operation* op) {
      all_operations.insert(op);
      for (Value result : op->getResults()) {
        all_internal_results.insert(result);
      }
      // We treat block arguments of inner blocks as "results", too, in

rootProject.name = 'walk-dependency-graph'...

            this.factoryMaker = factoryMaker
        }

        ClasspathElementTransformFactory createFactory(ClasspathBuilder builder, ClasspathWalker walker) {
            return factoryMaker.apply(builder, walker)
        }

        @Override
        String toString() {
            return super.toString().toLowerCase(Locale.ENGLISH)
        }
    }

			decoded = v
		}
	}
	setflags, err := walk("", "", decoded)
	if err != nil {
		return []string{}, err
	}
	sort.Strings(setflags)
	return setflags, nil
}

func walk(path, separator string, obj any) ([]string, error) {
	switch v := obj.(type) {
	case map[string]any:
		accum := make([]string, 0)
		for key, vv := range v {

func (n *miniNode) SetTypecheck(x uint8) {
	if x > 2 {
		panic(fmt.Sprintf("cannot SetTypecheck %d", x))
	}
	n.bits.set2(miniTypecheckShift, x)
}

func (n *miniNode) Walked() bool     { return n.bits&miniWalked != 0 }
func (n *miniNode) SetWalked(x bool) { n.bits.set(miniWalked, x) }

// Empty, immutable graph structure.

func (n *miniNode) Init() Nodes { return Nodes{} }

#include "tensorflow/compiler/mlir/quantization/common/quantization_lib/quantization_utils.h"

namespace mlir {
namespace TFL {

void ConvertTFLQuantOpsToMlirQuantOps(func::FuncOp func) {
  OpBuilder b(func);
  func.walk([&](Operation* op) {
    b.setInsertionPoint(op);
    if (auto dq = llvm::dyn_cast<DequantizeOp>(op)) {
      auto dcast = b.create<quantfork::DequantizeCastOp>(
          dq.getLoc(), dq.getOutput().getType(), dq.getInput());

				checkAtomicAddAssignment(pass, n.Lhs[i], call)
			}
		}
	})
	return nil, nil
}

// checkAtomicAddAssignment walks the atomic.Add* method calls checking
// for assigning the return value to the same variable being used in the
// operation
func checkAtomicAddAssignment(pass *analysis.Pass, left ast.Expr, call *ast.CallExpr) {

// function, so all stablehlo functions are of no use in the top-level module.
//
// Walk the module to find functions with `_from_xla_call_module` attribute,
// and remove them.
void RemoveSerializedStablehloFunctions(ModuleOp module) {
  module.walk([&](func::FuncOp f) {
    if (f->hasAttr(kFromXlaCallModuleAttrName)) {
      f->erase();
    }
  });
}

        parent.children.each {
            walk(it) {
                if (predicate.isSatisfiedBy(it)) {
                    matches << it
                }
            }
        }
        matches
    }

    List<BuildOperationRecord.Progress> progress(Class<?> clazz) {
        return all().collect { it.progress(clazz) }.flatten()
    }

    void walk(Action<? super BuildOperationRecord> action) {

      *mlir_module_, DeviceType(DEVICE_TPU_XLA_JIT)));

  FuncOp main = mlir_module_->lookupSymbol<FuncOp>("main");
  ASSERT_TRUE(main);

  bool has_cluster_op = false;
  main.walk([&](mlir::tf_device::ClusterOp) {
    has_cluster_op = true;
    return mlir::WalkResult::interrupt();
  });

  EXPECT_FALSE(has_cluster_op);
}

TEST_F(LowerClusterToRuntimeOpsTest, LowersClusterOpsCPU) {