WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package schema

// Visitor recursively walks through a structural schema.
type Visitor struct {
	// Structural is called on each Structural node in the schema, before recursing into
	// the subtrees. It is allowed to mutate s. Return true if something has been changed.

    scm 'some:unresolved:2.5'
}

// tag::walk-task[]
tasks.register('walkDependencyGraph', DependencyGraphWalk) {
    dependencies = configurations.scm.incoming
}

abstract class DependencyGraphWalk extends DefaultTask {

    @Input
    abstract Property<ResolvableDependencies> getDependencies()

    @TaskAction
    void walk() {

  return count;
}

void NameAnonymousIteratorsPass::runOnOperation() {
  int count = 1;
  getOperation().walk(
      [&](TF::AnonymousIteratorOp op) { count = replace(op, count); });
  getOperation().walk(
      [&](TF::AnonymousIteratorV2Op op) { count = replace(op, count); });
  getOperation().walk(
      [&](TF::AnonymousIteratorV3Op op) { count = replace(op, count); });
}

}  // namespace

    scm("some:unresolved:2.5")
}

// tag::walk-task[]
tasks.register<DependencyGraphWalk>("walkDependencyGraph") {
    dependencies = configurations["scm"].incoming
}

abstract class DependencyGraphWalk: DefaultTask() {

    @get:Input
    abstract val dependencies: Property<ResolvableDependencies>

    @TaskAction
    fun walk() {

// Package tests defines an Analyzer that checks for common mistaken
// usages of tests and examples.
//
// # Analyzer tests
//
// tests: check for common mistaken usages of tests and examples
//
// The tests checker walks Test, Benchmark, Fuzzing and Example functions checking
// malformed names, wrong signatures and examples documenting non-existent
// identifiers.
//
// Please see the documentation for package testing in golang.org/pkg/testing

    op->removeAttr(kShapeInvariantAttr);
}
void DropWhileShapeInvariantPass::runOnOperation() {
  getOperation().walk([](Operation* op) { DropWhileShapeInvariantAttr(op); });
}

void DropWhileShapeInvariantInDeviceClusterPass::runOnOperation() {
  getOperation().walk([](tf_device::ClusterOp cluster) {
    cluster.walk([](Operation* op) { DropWhileShapeInvariantAttr(op); });
  });
}
}  // namespace

	g(&f(x[:])[0])
}

type Node struct {
	s           string
	left, right *Node
}

func walk(np **Node) int { // ERROR "leaking param content: np"
	n := *np
	w := len(n.s)
	if n == nil {
		return 0
	}
	wl := walk(&n.left)
	wr := walk(&n.right)
	if wl < wr {
		n.left, n.right = n.right, n.left // ERROR "ignoring self-assignment"
		wl, wr = wr, wl
	}
	*np = n

		panicunsafestringlen()
	}

	if uintptr(len) > -uintptr(ptr) {
		if ptr == nil {
			panicunsafestringnilptr()
		}
		panicunsafestringlen()
	}
}

// Keep this code in sync with cmd/compile/internal/walk/builtin.go:walkUnsafeString
func unsafestring64(ptr unsafe.Pointer, len64 int64) {
	len := int(len64)
	if int64(len) != len64 {
		panicunsafestringlen()
	}
	unsafestring(ptr, len)
}

import org.gradle.internal.reflect.validation.TypeValidationContext;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Walks properties declared by the type.
 */
@ServiceScope(Scope.Global.class)
public interface PropertyWalker {
    void visitProperties(Object instance, TypeValidationContext validationContext, PropertyVisitor visitor);

		return false
	}
	typeof, _ := typecheck(&TypeConfig{}, f)
	changed := false

	// step 1: Find all the nils with the offending types.
	// Compute their replacement.
	badNils := map[any]ast.Expr{}
	walk(f, func(n any) {
		if i, ok := n.(*ast.Ident); ok && i.Name == "nil" && badType(typeof[n]) {
			badNils[n] = &ast.BasicLit{ValuePos: i.NamePos, Kind: token.INT, Value: "0"}
		}
	})