externalFunctions = listOf(::newD),
    defaultImports = listOf(DefaultFqName("com.example", "newD"))
)


object SimpleAnalysisDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        printResolutionResults(
            schema.resolve(
                """
                    val myB = b()

                    a = myB
                    val myD = newD("shared")

                    val c1 = c(1)

// set its O_CLOEXEC bit, using two system calls.
func dupCloseOnExecOld(fd int) (int, string, error) {
	syscall.ForkLock.RLock()
	defer syscall.ForkLock.RUnlock()
	newfd, err := syscall.Dup(fd)
	if err != nil {
		return -1, "dup", err
	}
	syscall.CloseOnExec(newfd)
	return newfd, "", nil
}

// Fchdir wraps syscall.Fchdir.
func (fd *FD) Fchdir() error {
	if err := fd.incref(); err != nil {
		return err
	}
	defer fd.decref()

}

func StopIO(fd int) error {
	return ENOSYS
}

func Listen(fd int, backlog int) error {
	return ENOSYS
}

func Accept(fd int) (int, Sockaddr, error) {
	var newfd int32
	errno := sock_accept(int32(fd), 0, unsafe.Pointer(&newfd))
	return int(newfd), nil, errnoErr(errno)
}

func Connect(fd int, sa Sockaddr) error {
	return ENOSYS
}

func Recvfrom(fd int, p []byte, flags int) (n int, from Sockaddr, err error) {

//go:build darwin || dragonfly || freebsd || (linux && !arm64 && !loong64 && !riscv64) || netbsd || openbsd

package main

import "syscall"

func dup2(oldfd, newfd int) error {
	return syscall.Dup2(oldfd, newfd)

// license that can be found in the LICENSE file.

//go:build (linux && arm64) || (linux && loong64) || (linux && riscv64)

package main

import "syscall"

func dup2(oldfd, newfd int) error {
	return syscall.Dup3(oldfd, newfd, 0)

}


class C(var x: Int = 0) {
    @Builder
    fun d(newD: D): C {
        this.d = newD
        return this
    }

    @get:Restricted
    var d: D = D()

    @get:Restricted
    val y = "test"

    @Restricted
    fun f(y: String) = 0
}


class D {
    @get:Restricted
    var id: String = "none"
}

		}
	}
}

func TestWasip1NewFileListener(t *testing.T) {
	if l, ok := newFileListener(newFD("tcp", -1)).(*TCPListener); !ok {
		t.Errorf("newFileListener: tcp listener type mismatch: %T", l)
	} else {
		testIsTCPAddr(t, "Addr", l.Addr())
	}
}

func TestWasip1NewFileConn(t *testing.T) {
	if c, ok := newFileConn(newFD("tcp", -1)).(*TCPConn); !ok {
		t.Errorf("newFileConn: tcp conn type mismatch: %T", c)
	} else {

import org.gradle.internal.declarativedsl.demo.resolve


object AssignmentResolverDemo {
    @JvmStatic
    fun main(args: Array<String>) {
        val resolution = schema.resolve(
            """
            val myD = newD("shared")

            val c1 = c(1)
            c1.d = myD
            str = c1.d.id
            """.trimIndent()
        )
        printResolutionResults(resolution)
        printResolvedAssignments(resolution)

	}
	laddr, err = readPlan9Addr(net, netdir+"/"+proto+"/"+name+"/local")
	if err != nil {
		f.Close()
		return nil, err
	}
	return newFD(proto, name, nil, f, nil, laddr, nil)
}

func (fd *netFD) netFD() (*netFD, error) {
	return newFD(fd.net, fd.n, fd.listen, fd.ctl, fd.data, fd.laddr, fd.raddr)
}

func (fd *netFD) acceptPlan9() (nfd *netFD, err error) {
	defer func() { fixErr(err) }()

	// fd_close, and sock_shutdown on the resulting connection. We
	// intercept applicable netFD calls on this instance, and then pass
	// the remainder of the netFD calls to fakeNetFD.
	*fakeNetFD
}

func newFD(net string, sysfd int) *netFD {
	return newPollFD(net, poll.FD{
		Sysfd:         sysfd,
		IsStream:      true,
		ZeroReadIsEOF: true,
	})
}

func newPollFD(net string, pfd poll.FD) *netFD {
	var laddr Addr