appendWalkStmt(init, a)
	}
}

func anylit(n ir.Node, var_ ir.Node, init *ir.Nodes) {
	t := n.Type()
	switch n.Op() {
	default:
		base.Fatalf("anylit: not lit, op=%v node=%v", n.Op(), n)

	case ir.ONAME:
		n := n.(*ir.Name)
		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, var_, n))

	case ir.OMETHEXPR:
		n := n.(*ir.SelectorExpr)
		anylit(n.FuncName(), var_, init)

	case ir.OPTRLIT:

kind: feature
area: installation
docs:
- 'https://istio.io/latest/docs/setup/platform-setup/openshift/'
releaseNotes:
- |

	do = func(x Node) bool {
		return cond(x) || DoChildren(x, do)
	}
	return do(n)
}

// AnyList calls Any(x, cond) for each node x in the list, in order.
// If any call returns true, AnyList stops and returns true.
// Otherwise, AnyList returns false after calling Any(x, cond)
// for every x in the list.
func AnyList(list Nodes, cond func(Node) bool) bool {
	for _, x := range list {
		if Any(x, cond) {
			return true

package main

// Zero returns the zero value of T
func Zero[T any]() (_ T) {
	return
}

type AnyInt[X any] int

func (AnyInt[X]) M() {
	var have interface{} = Zero[X]()
	var want interface{} = Zero[MyInt]()

	if have != want {
		println("FAIL")
	}
}

type I interface{ M() }

type MyInt int
type U = AnyInt[MyInt]

var x = U(0)
var i I = x

func main() {
	x.M()
	U.M(x)
	(*U).M(&x)

		// 0-octals
		{IntLit, "0", "0", ""},
		{IntLit, "0123", "0123", ""},

		{IntLit, "08123", "08123", "invalid digit '8' in octal literal"},
		{IntLit, "01293", "01293", "invalid digit '9' in octal literal"},
		{IntLit, "0F.", "0 F .", ""}, // only accept 0-9
		{IntLit, "0123F.", "0123 F .", ""},
		{IntLit, "0123456x", "0123456 x", ""},

		// decimals
		{IntLit, "1", "1", ""},

        setup:
        def externalInitFile = temporaryFolder.createFile("initscripts/somePath/anInit.gradle")
        externalInitFile << """
        buildFinished {
            println "Gradle Plugin received build finished!"
        }
        """
        when:
        initFile << """
        apply from: "somePath/anInit.gradle"
        """
        then:
        def executed = succeeds('tasks')

from contextlib import asynccontextmanager as asynccontextmanager
from typing import AsyncGenerator, ContextManager, TypeVar

import anyio
from anyio import CapacityLimiter
from starlette.concurrency import iterate_in_threadpool as iterate_in_threadpool  # noqa
from starlette.concurrency import run_in_threadpool as run_in_threadpool  # noqa
from starlette.concurrency import (  # noqa
    run_until_first_complete as run_until_first_complete,
)

apiVersion: release-notes/v2
kind: feature
area: documentation
docs:
- 'https://istio.io/latest/docs/setup/platform-setup/openshift/'
releaseNotes:
- |

	if err != nil {
		t.Fatal(err)
	}

	// Capture original address and value of a BasicLit node
	// which will undergo formatting changes during printing.
	wantLit := file.Decls[0].(*ast.GenDecl).Specs[0].(*ast.ValueSpec).Values[0].(*ast.BasicLit)
	wantVal := wantLit.Value

	var buf bytes.Buffer
	if err = Node(&buf, fset, file); err != nil {
		t.Fatal("Node failed:", err)
	}
	diff(t, buf.Bytes(), []byte(golden))

func (s *bitMask) IsSet(bit int) bool {
	if bit < 0 || bit >= 64 {
		return false
	}
	return (*s & (1 << uint64(bit))) > 0
}

// AnySet checks bit in mask to see if any provided bit is set to one
func (s *bitMask) AnySet(bits []int) bool {
	for _, b := range bits {
		if s.IsSet(b) {
			return true
		}
	}
	return false
}

// IsEqual checks if masks are equal