Leonardo Sarra <******@****.***> 1718116194 +0200

// formed are pruned. If the child island inner ops consume the parent island
// control result, the child island inner ops will have that respective control
// input pruned. Results of the parent island that are consumed by the child
// island are replaced by the respective inner ops result from the parent
// island.
void GetNewIslandResultsAndForwardResults(

class Outer {
    @get:Restricted
    val inner: Inner = Inner()

    @Configuring(propertyName = "inner")
    fun configureInner(fn: Functional) {
        fn.configure(inner)
    }

    @Configuring(propertyName = "inner")
    fun configureInnerWithGeneric(fn: GenericFunctional<Inner>) {
        fn.configure(inner)
    }
}


interface Functional {
    fun configure(inner: Inner)
}

  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
      // the sense that they're values produced inside this op.
      for (Region& region : op->getRegions()) {

    SettableFuture<Object> async = SettableFuture.create();
    SettableFuture<Object> inner = SettableFuture.create();
    async.setFuture(inner);
    async.cancel(true);
    assertTrue(inner.isCancelled());
    assertTrue(inner.wasInterrupted());
    assertThrows(CancellationException.class, () -> inner.get());
  }

  public void testCancel_resultCancelsInner() throws Exception {

			name: "empty map at depth = 1",
			given: func() Mapper {
				// root (dest port)
				//   15001:
				//     inner (dest ip):
				//       <no matches>
				//       fallback: chain
				inner := NewDestinationIP()
				inner.OnNoMatch = ToChain("chain")

				root := NewDestinationPort()
				root.Map["15001"] = ToMatcher(inner.Matcher)
				return root
			},
			want: func() *matcher.Matcher {
				// dest port
				// 15001: chain

// provided decorator that wraps an inner http.ResponseWriter object.
// The user-provided decorator object must return the inner (decorated)
// http.ResponseWriter object via the Unwrap function.
type UserProvidedDecorator interface {
	http.ResponseWriter

	// Unwrap returns the inner http.ResponseWriter object associated
	// with the user-provided decorator.

    def "should not remove #modifier inner class if no API is declared"() {
        given:
        def api = toApi 'A': """
            public class A {
               $modifier class Inner {
                  public void foo() {}
               }
            }
        """

        when:
        def outer = api.classes.A
        def inner = api.classes['A$Inner']

! stdout ^new/sub/v2
stdout ^new/sub/inner/x # not new/sub/v2/inner/x

go build old/p1 new/p1

-- new/go.mod --
module "new/v2"
-- new/new.go --
package new

import _ "new/v2/p2"
-- new/p1/p1.go --
package p1

import _ "old/p2"
import _ "new/v2"
import _ "new/v2/p2"
import _ "new/sub/v2/x/v1/y" // v2 is module, v1 is directory in module

    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Bar Bar
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
}

public class CodeFragment$run$Foo {
    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
    public method call(): void