// 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);
      }

func (s simplifier) Visit(node ast.Node) ast.Visitor {
	switch n := node.(type) {
	case *ast.CompositeLit:
		// array, slice, and map composite literals may be simplified
		outer := n
		var keyType, eltType ast.Expr
		switch typ := outer.Type.(type) {
		case *ast.ArrayType:
			eltType = typ.Elt
		case *ast.MapType:
			keyType = typ.Key
			eltType = typ.Value
		}

		if eltType != nil {
			var ktyp reflect.Value

    }

    def "inner class name format"() {
        expect:
        MethodDescription.name('a').owner(Outer.Inner).toString() == 'org.gradle.internal.reflect.MethodDescriptionTest$Outer$Inner#a'
    }

    class Outer {
        static class Inner {

        }
    }

// issue 2086
// was calling makeclosure twice on the closure

package bug354

type Inner struct {
	F func() error
}

type Outer struct {
	Inners []Inner
}

// calls makeclosure twice on same closure

type Symbol interface{}

type Value interface {
	String() string
}

type Object interface {
	String() string
}

type Scope struct {
	outer *Scope
	elems map[string]Object
}

func (s *Scope) findouter(name string) (*Scope, Object) {
	return s.outer.findouter(name)
}

func (s *Scope) Resolve(name string) (sym Symbol) {
	if _, obj := s.findouter(name); obj != nil {
		sym = obj.(Symbol)
	}
	return

  protected Queue<String> create() {
    TestQueue<String> inner = new TestQueue<>();
    Queue<String> outer = Synchronized.queue(inner, null);
    inner.mutex = outer;
    outer.add("foo"); // necessary because we try to remove elements later on
    return outer;
  }

  private static final class TestQueue<E> implements Queue<E> {
    private final Queue<E> delegate = Lists.newLinkedList();

        def outer = new RuntimeException("message", original)

        when:
        def transported = transport(outer)

        then:
        transported instanceof RuntimeException
        transported.class == RuntimeException.class
        transported.message == "message"
        transported.stackTrace == outer.stackTrace

        and:

	fn := clo.Func

	args := make([]ir.Node, len(fn.ClosureVars))
	for i, v := range fn.ClosureVars {
		var outer ir.Node
		outer = v.Outer
		if !v.Byval() {
			outer = typecheck.NodAddrAt(fn.Pos(), outer)
		}
		args[i] = typecheck.Expr(outer)
	}
	return args
}

func walkMethodValue(n *ir.SelectorExpr, init *ir.Nodes) ir.Node {

  }

  public void testConverter_nullConversions() {
    for (CaseFormat outer : CaseFormat.values()) {
      for (CaseFormat inner : CaseFormat.values()) {
        assertNull(outer.converterTo(inner).convert(null));
        assertNull(outer.converterTo(inner).reverse().convert(null));
      }
    }
  }

  public void testConverter_toString() {
    assertEquals(

}

type privateVal[T comparable] struct {
	val T
}

//go:noinline
func (l *privateVal[T]) check(want T) {
	if l.val != want {
		panic("hi")
	}
}

type Outer struct {
	val privateVal[string]
}

func Test3() {
	var o Outer
	o.val.check("")
	_ = IVal[string](&o.val)