// 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.

require example.net/outer/inner v0.1.0
-- a/a.go --
package a
-- a/a_test.go --
package a_test

import _ "example.net/outer/inner"
-- b/go.mod --
module example.net/b

go 1.21

require example.net/outer v0.1.0
-- b/b.go --
package b
-- b/b_test.go --
package b_test

import _ "example.net/outer/inner"
-- inner/go.mod --
module example.net/outer/inner

go 1.21
-- inner/inner.go --
package inner

func f6[P interface { *Tree[P] }, Q any ]() {}

func _() {
        f1 /* ERROR "cannot infer P" */ ()
        f2 /* ERROR "cannot infer P" */ ()
        f3 /* ERROR "cannot infer P" */ ()
        f4 /* ERROR "cannot infer P" */ ()
        f5 /* ERROR "cannot infer P" */ ()
        f6 /* ERROR "cannot infer P" */ ()
}

type Tree[P any] struct {
        left, right *Tree[P]
        data P
}

    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']

	// combination of signer name and a label selector.
	//
	// Kubelet performs aggressive normalization of the PEM contents written
	// into the pod filesystem.  Esoteric PEM features such as inter-block
	// comments and block headers are stripped.  Certificates are deduplicated.
	// The ordering of certificates within the file is arbitrary, and Kubelet
	// may change the order over time.
	//

! 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

        }
    }

    inner class AnonymousInitializerBuilder {
        fun buildClassInitializer(firSymbol: FirAnonymousInitializerSymbol): KaClassInitializerSymbol {
            return symbolsCache.cache(firSymbol) { KaFirClassInitializerSymbol(firSymbol, analysisSession) }
        }
    }

    inner class TypeBuilder {
        fun buildKtType(coneType: ConeKotlinType): KaType {

    // 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

	return &ContainerWrapper{v1.Container{}}
}

// Obj returns the inner Container.
func (c *ContainerWrapper) Obj() v1.Container {
	return c.Container
}

// Name sets `n` as the name of the inner Container.
func (c *ContainerWrapper) Name(n string) *ContainerWrapper {
	c.Container.Name = n
	return c
}

// Image sets `image` as the image of the inner Container.

  private String leave() {
    return "leave";
  }

  public final void testMutualExclusion() throws Exception {
    thread1.callAndAssertReturns(enter());
    thread2.callAndAssertBlocks(enter());
    thread1.callAndAssertReturns(leave());
    thread2.assertPriorCallReturns(enter());
  }

  public final void testTryEnter() throws Exception {
    thread1.callAndAssertReturns(true, tryEnter());