WIP: support for the CH32V003 chip

.github/workflows/linux.yml

@@ -134,19 +134,17 @@ jobs:
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-        with:
-          submodules: true
       - name: Install Go
         uses: actions/setup-go@v5
         with:
           go-version: '1.22'
           cache: true
       - name: Install wasmtime
-        uses: bytecodealliance/actions/wasmtime/setup@v1
-        with:
-          version: "19.0.1"
-      - name: Install wasm-tools
-        uses: bytecodealliance/actions/wasm-tools/setup@v1
+        run: |
+          mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
+          curl https://github.com/bytecodealliance/wasmtime/releases/download/v14.0.4/wasmtime-v14.0.4-x86_64-linux.tar.xz -o wasmtime-v14.0.4-x86_64-linux.tar.xz -SfL
+          tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v14.0.4-x86_64-linux.tar.xz --strip-components=1 wasmtime-v14.0.4-x86_64-linux/*
+          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
       - name: Download release artifact
         uses: actions/download-artifact@v4
         with:
@@ -156,8 +154,8 @@ jobs:
           mkdir -p ~/lib
           tar -C ~/lib -xf tinygo.linux-amd64.tar.gz
           ln -s ~/lib/tinygo/bin/tinygo ~/go/bin/tinygo
+      - run: make tinygo-test-wasi-fast
       - run: make tinygo-test-wasip1-fast
-      - run: make tinygo-test-wasip2-fast
       - run: make smoketest
   assert-test-linux:
     # Run all tests that can run on Linux, with LLVM assertions enabled to catch
@@ -189,11 +187,11 @@ jobs:
         with:
           node-version: '18'
       - name: Install wasmtime
-        uses: bytecodealliance/actions/wasmtime/setup@v1
-        with:
-          version: "19.0.1"
-      - name: Setup `wasm-tools`
-        uses: bytecodealliance/actions/wasm-tools/setup@v1
+        run: |
+          mkdir -p $HOME/.wasmtime $HOME/.wasmtime/bin
+          curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v14.0.4/wasmtime-v14.0.4-x86_64-linux.tar.xz -o wasmtime-v14.0.4-x86_64-linux.tar.xz -SfL
+          tar -C $HOME/.wasmtime/bin --wildcards -xf wasmtime-v14.0.4-x86_64-linux.tar.xz --strip-components=1 wasmtime-v14.0.4-x86_64-linux/*
+          echo "$HOME/.wasmtime/bin" >> $GITHUB_PATH
       - name: Restore LLVM source cache
         uses: actions/cache/restore@v4
         id: cache-llvm-source

.github/workflows/windows.yml

@@ -220,5 +220,5 @@ jobs:
         shell: bash
         working-directory: build
         run: 7z x release.zip -r
-      - name: Test stdlib packages on wasip1
-        run: make tinygo-test-wasip1-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo
+      - name: Test stdlib packages on wasi
+        run: make tinygo-test-wasi-fast TINYGO=$(PWD)/build/tinygo/bin/tinygo

.gitignore

@@ -1,6 +1,3 @@
-go.work
-go.work.sum
-
 docs/_build
 src/device/avr/*.go
 src/device/avr/*.ld
@@ -20,7 +17,9 @@ src/device/kendryte/*.go
 src/device/kendryte/*.s
 src/device/rp/*.go
 src/device/rp/*.s
-./vendor
+src/device/wch/*.go
+src/device/wch/*.s
+vendor
 llvm-build
 llvm-project
 build/*

.gitmodules

@@ -39,9 +39,3 @@
 	path = src/net
 	url = https://github.com/tinygo-org/net.git
 	branch = dev
-[submodule "lib/wasi-cli"]
-	path = lib/wasi-cli
-	url = https://github.com/WebAssembly/wasi-cli
-[submodule "src/vendor/github.com/ydnar/wasm-tools-go"]
-	path = src/vendor/github.com/ydnar/wasm-tools-go
-	url = https://github.com/ydnar/wasm-tools-go.git

GNUmakefile

@@ -185,7 +185,7 @@ fmt-check:
 	@unformatted=$$(gofmt -l $(FMT_PATHS)); [ -z "$$unformatted" ] && exit 0; echo "Unformatted:"; for fn in $$unformatted; do echo "  $$fn"; done; exit 1
 
 
-gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp
+gen-device: gen-device-avr gen-device-esp gen-device-nrf gen-device-sam gen-device-sifive gen-device-kendryte gen-device-nxp gen-device-rp gen-device-wch
 ifneq ($(STM32), 0)
 gen-device: gen-device-stm32
 endif
@@ -237,6 +237,10 @@ gen-device-renesas: build/gen-device-svd
 	./build/gen-device-svd -source=https://github.com/tinygo-org/renesas-svd lib/renesas-svd/ src/device/renesas/
 	GO111MODULE=off $(GO) fmt ./src/device/renesas
 
+gen-device-wch: build/gen-device-svd
+	./build/gen-device-svd -source=https://github.com/ch32-rs/ch32-rs/ lib/cmsis-svd/data/WCH-Community/ src/device/wch
+	GO111MODULE=off $(GO) fmt ./src/device/wch
+
 # Get LLVM sources.
 $(LLVM_PROJECTDIR)/llvm:
 	git clone -b tinygo_xtensa_release_18.1.2 --depth=1 https://github.com/tinygo-org/llvm-project $(LLVM_PROJECTDIR)
@@ -268,11 +272,6 @@ lib/wasi-libc/sysroot/lib/wasm32-wasi/libc.a:
 	@if [ ! -e lib/wasi-libc/Makefile ]; then echo "Submodules have not been downloaded. Please download them using:\n  git submodule update --init"; exit 1; fi
 	cd lib/wasi-libc && $(MAKE) -j4 EXTRA_CFLAGS="-O2 -g -DNDEBUG -mnontrapping-fptoint -msign-ext" MALLOC_IMPL=none CC="$(CLANG)" AR=$(LLVM_AR) NM=$(LLVM_NM)
 
-# Generate WASI syscall bindings
-.PHONY: wasi-syscall
-wasi-syscall:
-	wit-bindgen-go generate -o ./src/internal -p internal --versioned ./lib/wasi-cli/wit
-
 # Check for Node.js used during WASM tests.
 NODEJS_VERSION := $(word 1,$(subst ., ,$(shell node -v | cut -c 2-)))
 MIN_NODEJS_VERSION=18
@@ -435,36 +434,15 @@ tinygo-test-wasi:
 	$(TINYGO) test -target wasip1 $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
 tinygo-test-wasip1:
 	GOOS=wasip1 GOARCH=wasm $(TINYGO) test $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW) ./tests/runtime_wasi
+tinygo-test-wasi-fast:
+	$(TINYGO) test -target wasip1 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
 tinygo-test-wasip1-fast:
-	$(TINYGO) test -target=wasip1 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
-
-tinygo-test-wasip2-slow:
-	$(TINYGO) test -target=wasip2 $(TEST_PACKAGES_SLOW)
-tinygo-test-wasip2-fast:
-	$(TINYGO) test -target=wasip2 $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
-
-tinygo-test-wasip2-sum-slow:
-	TINYGO=$(TINYGO) \
-	TARGET=wasip2 \
-	TESTOPTS="-x -work" \
-	PACKAGES="$(TEST_PACKAGES_SLOW)" \
-	gotestsum --raw-command -- ./tools/tgtestjson.sh
-tinygo-test-wasip2-sum-fast:
-	TINYGO=$(TINYGO) \
-	TARGET=wasip2 \
-	TESTOPTS="-x -work" \
-	PACKAGES="$(TEST_PACKAGES_FAST)" \
-	gotestsum --raw-command -- ./tools/tgtestjson.sh
-tinygo-bench-wasip1:
+	GOOS=wasip1 GOARCH=wasm $(TINYGO) test $(TEST_PACKAGES_FAST) ./tests/runtime_wasi
+tinygo-bench-wasi:
 	$(TINYGO) test -target wasip1 -bench . $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW)
-tinygo-bench-wasip1-fast:
+tinygo-bench-wasi-fast:
 	$(TINYGO) test -target wasip1 -bench . $(TEST_PACKAGES_FAST)
 
-tinygo-bench-wasip2:
-	$(TINYGO) test -target wasip2 -bench . $(TEST_PACKAGES_FAST) $(TEST_PACKAGES_SLOW)
-tinygo-bench-wasip2-fast:
-	$(TINYGO) test -target wasip2 -bench . $(TEST_PACKAGES_FAST)
-
 # Test external packages in a large corpus.
 test-corpus:
 	CGO_CPPFLAGS="$(CGO_CPPFLAGS)" CGO_CXXFLAGS="$(CGO_CXXFLAGS)" CGO_LDFLAGS="$(CGO_LDFLAGS)" $(GO) test $(GOTESTFLAGS) -timeout=1h -buildmode exe -tags byollvm -run TestCorpus . -corpus=testdata/corpus.yaml
@@ -809,6 +787,8 @@ endif
 	@$(MD5SUM) test.hex
 	$(TINYGO) build -size short -o test.hex -target=maixbit             examples/blinky1
 	@$(MD5SUM) test.hex
+	$(TINYGO) build -size short -o test.hex -target=nanoch32v003        examples/blinky1
+	@$(MD5SUM) test.hex
 ifneq ($(WASM), 0)
 	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/export
 	$(TINYGO) build -size short -o wasm.wasm -target=wasm               examples/wasm/main
@@ -858,7 +838,6 @@ build/release: tinygo gen-device wasi-libc $(if $(filter 1,$(USE_SYSTEM_BINARYEN
 	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-bottom-half/headers
 	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/arch
 	@mkdir -p build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
-	@mkdir -p build/release/tinygo/lib/wasi-cli/
 	@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0
 	@mkdir -p build/release/tinygo/pkg/thumbv6m-unknown-unknown-eabi-cortex-m0plus
 	@mkdir -p build/release/tinygo/pkg/thumbv7em-unknown-unknown-eabi-cortex-m4
@@ -918,7 +897,6 @@ endif
 	@cp -rp lib/wasi-libc/libc-top-half/musl/src/string             build/release/tinygo/lib/wasi-libc/libc-top-half/musl/src
 	@cp -rp lib/wasi-libc/libc-top-half/musl/include                build/release/tinygo/lib/wasi-libc/libc-top-half/musl
 	@cp -rp lib/wasi-libc/sysroot                                   build/release/tinygo/lib/wasi-libc/sysroot
-	@cp -rp lib/wasi-cli/wit                                        build/release/tinygo/lib/wasi-cli/wit
 	@cp -rp llvm-project/compiler-rt/lib/builtins build/release/tinygo/lib/compiler-rt-builtins
 	@cp -rp llvm-project/compiler-rt/LICENSE.TXT  build/release/tinygo/lib/compiler-rt-builtins
 	@cp -rp src                          build/release/tinygo/src

builder/build.go

@@ -840,11 +840,11 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 					"--output", result.Executable,
 				)
 
-				wasmopt := goenv.Get("WASMOPT")
 				if config.Options.PrintCommands != nil {
-					config.Options.PrintCommands(wasmopt, args...)
+					config.Options.PrintCommands(goenv.Get("WASMOPT"), args...)
 				}
-				cmd := exec.Command(wasmopt, args...)
+
+				cmd := exec.Command(goenv.Get("WASMOPT"), args...)
 				cmd.Stdout = os.Stdout
 				cmd.Stderr = os.Stderr
 
@@ -854,62 +854,6 @@ func Build(pkgName, outpath, tmpdir string, config *compileopts.Config) (BuildRe
 				}
 			}
 
-			// Run wasm-tools for component-model binaries
-			witPackage := strings.ReplaceAll(config.Target.WITPackage, "{root}", goenv.Get("TINYGOROOT"))
-			if config.Options.WITPackage != "" {
-				witPackage = config.Options.WITPackage
-			}
-			witWorld := config.Target.WITWorld
-			if config.Options.WITWorld != "" {
-				witWorld = config.Options.WITWorld
-			}
-			if witPackage != "" && witWorld != "" {
-
-				// wasm-tools component embed -w wasi:cli/command
-				// 		$$(tinygo env TINYGOROOT)/lib/wasi-cli/wit/ main.wasm -o embedded.wasm
-				args := []string{
-					"component",
-					"embed",
-					"-w", witWorld,
-					witPackage,
-					result.Executable,
-					"-o", result.Executable,
-				}
-
-				wasmtools := goenv.Get("WASMTOOLS")
-				if config.Options.PrintCommands != nil {
-					config.Options.PrintCommands(wasmtools, args...)
-				}
-				cmd := exec.Command(wasmtools, args...)
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-
-				err := cmd.Run()
-				if err != nil {
-					return fmt.Errorf("wasm-tools failed: %w", err)
-				}
-
-				// wasm-tools component new embedded.wasm -o component.wasm
-				args = []string{
-					"component",
-					"new",
-					result.Executable,
-					"-o", result.Executable,
-				}
-
-				if config.Options.PrintCommands != nil {
-					config.Options.PrintCommands(wasmtools, args...)
-				}
-				cmd = exec.Command(wasmtools, args...)
-				cmd.Stdout = os.Stdout
-				cmd.Stderr = os.Stderr
-
-				err = cmd.Run()
-				if err != nil {
-					return fmt.Errorf("wasm-tools failed: %w", err)
-				}
-			}
-
 			// Print code size if requested.
 			if config.Options.PrintSizes == "short" || config.Options.PrintSizes == "full" {
 				packagePathMap := make(map[string]string, len(lprogram.Packages))

builder/builder_test.go

@@ -27,6 +27,7 @@ func TestClangAttributes(t *testing.T) {
 		"cortex-m33",
 		"cortex-m4",
 		"cortex-m7",
+		"ch32v003",
 		"esp32c3",
 		"fe310",
 		"gameboy-advance",
@@ -34,7 +35,6 @@ func TestClangAttributes(t *testing.T) {
 		"nintendoswitch",
 		"riscv-qemu",
 		"wasip1",
-		"wasip2",
 		"wasm",
 		"wasm-unknown",
 	}
@@ -62,7 +62,6 @@ func TestClangAttributes(t *testing.T) {
 		{GOOS: "windows", GOARCH: "amd64"},
 		{GOOS: "windows", GOARCH: "arm64"},
 		{GOOS: "wasip1", GOARCH: "wasm"},
-		{GOOS: "wasip2", GOARCH: "wasm"},
 	} {
 		name := "GOOS=" + options.GOOS + ",GOARCH=" + options.GOARCH
 		if options.GOARCH == "arm" {

cgo/libclang.go

@@ -642,6 +642,13 @@ func (p *cgoPackage) addErrorAfter(pos token.Pos, after, msg string) {
 
 // addErrorAt is a utility function to add an error to the list of errors.
 func (p *cgoPackage) addErrorAt(position token.Position, msg string) {
+	if filepath.IsAbs(position.Filename) {
+		// Relative paths for readability, like other Go parser errors.
+		relpath, err := filepath.Rel(p.currentDir, position.Filename)
+		if err == nil {
+			position.Filename = relpath
+		}
+	}
 	p.errors = append(p.errors, scanner.Error{
 		Pos: position,
 		Msg: msg,

compileopts/options.go

@@ -53,8 +53,6 @@ type Options struct {
 	Monitor         bool
 	BaudRate        int
 	Timeout         time.Duration
-	WITPackage      string // pass through to wasm-tools component embed invocation
-	WITWorld        string // pass through to wasm-tools component embed -w option
 }
 
 // Verify performs a validation on the given options, raising an error if options are not valid.

compileopts/target.go

@@ -62,8 +62,6 @@ type TargetSpec struct {
 	JLinkDevice      string   `json:"jlink-device,omitempty"`
 	CodeModel        string   `json:"code-model,omitempty"`
 	RelocationModel  string   `json:"relocation-model,omitempty"`
-	WITPackage       string   `json:"wit-package,omitempty"`
-	WITWorld         string   `json:"wit-world,omitempty"`
 }
 
 // overrideProperties overrides all properties that are set in child into itself using reflection.

compiler/compiler.go

@@ -1846,9 +1846,9 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 			return b.emitSV64Call(instr.Args, getPos(instr))
 		case strings.HasPrefix(name, "(device/riscv.CSR)."):
 			return b.emitCSROperation(instr)
-		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.Syscall") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscall"):
+		case strings.HasPrefix(name, "syscall.Syscall") || strings.HasPrefix(name, "syscall.RawSyscall"):
 			return b.createSyscall(instr)
-		case strings.HasPrefix(name, "syscall.rawSyscallNoError") || strings.HasPrefix(name, "golang.org/x/sys/unix.RawSyscallNoError"):
+		case strings.HasPrefix(name, "syscall.rawSyscallNoError"):
 			return b.createRawSyscallNoError(instr)
 		case name == "runtime.supportsRecover":
 			supportsRecover := uint64(0)
@@ -2017,8 +2017,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 			sizeValue := llvm.ConstInt(b.uintptrType, size, false)
 			layoutValue := b.createObjectLayout(typ, expr.Pos())
 			buf := b.createRuntimeCall("alloc", []llvm.Value{sizeValue, layoutValue}, expr.Comment)
-			align := b.targetData.ABITypeAlignment(typ)
-			buf.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 			return buf, nil
 		} else {
 			buf := llvmutil.CreateEntryBlockAlloca(b.Builder, typ, expr.Comment)
@@ -2225,7 +2223,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		sliceType := expr.Type().Underlying().(*types.Slice)
 		llvmElemType := b.getLLVMType(sliceType.Elem())
 		elemSize := b.targetData.TypeAllocSize(llvmElemType)
-		elemAlign := b.targetData.ABITypeAlignment(llvmElemType)
 		elemSizeValue := llvm.ConstInt(b.uintptrType, elemSize, false)
 
 		maxSize := b.maxSliceSize(llvmElemType)
@@ -2249,7 +2246,6 @@ func (b *builder) createExpr(expr ssa.Value) (llvm.Value, error) {
 		sliceSize := b.CreateBinOp(llvm.Mul, elemSizeValue, sliceCapCast, "makeslice.cap")
 		layoutValue := b.createObjectLayout(llvmElemType, expr.Pos())
 		slicePtr := b.createRuntimeCall("alloc", []llvm.Value{sliceSize, layoutValue}, "makeslice.buf")
-		slicePtr.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(elemAlign)))
 
 		// Extend or truncate if necessary. This is safe as we've already done
 		// the bounds check.

compiler/llvm.go

@@ -127,14 +127,12 @@ func (b *builder) emitPointerPack(values []llvm.Value) llvm.Value {
 
 		// Packed data is bigger than a pointer, so allocate it on the heap.
 		sizeValue := llvm.ConstInt(b.uintptrType, size, false)
-		align := b.targetData.ABITypeAlignment(packedType)
 		alloc := b.mod.NamedFunction("runtime.alloc")
 		packedAlloc := b.CreateCall(alloc.GlobalValueType(), alloc, []llvm.Value{
 			sizeValue,
 			llvm.ConstNull(b.dataPtrType),
 			llvm.Undef(b.dataPtrType), // unused context parameter
 		}, "")
-		packedAlloc.AddCallSiteAttribute(0, b.ctx.CreateEnumAttribute(llvm.AttributeKindID("align"), uint64(align)))
 		if b.NeedsStackObjects {
 			b.trackPointer(packedAlloc)
 		}

compiler/symbol.go

@@ -346,7 +346,7 @@ func (c *compilerContext) parsePragmas(info *functionInfo, f *ssa.Function) {
 // The list of allowed types is based on this proposal:
 // https://github.com/golang/go/issues/59149
 func (c *compilerContext) checkWasmImport(f *ssa.Function, pragma string) {
-	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" || c.pkg.Path() == "syscall" {
+	if c.pkg.Path() == "runtime" || c.pkg.Path() == "syscall/js" {
 		// The runtime is a special case. Allow all kinds of parameters
 		// (importantly, including pointers).
 		return
@@ -360,68 +360,38 @@ func (c *compilerContext) checkWasmImport(f *ssa.Function, pragma string) {
 		c.addError(f.Signature.Results().At(1).Pos(), fmt.Sprintf("%s: too many return values", pragma))
 	} else if f.Signature.Results().Len() == 1 {
 		result := f.Signature.Results().At(0)
-		if !isValidWasmType(result.Type(), siteResult) {
+		if !isValidWasmType(result.Type(), true) {
 			c.addError(result.Pos(), fmt.Sprintf("%s: unsupported result type %s", pragma, result.Type().String()))
 		}
 	}
 	for _, param := range f.Params {
 		// Check whether the type is allowed.
 		// Only a very limited number of types can be mapped to WebAssembly.
-		if !isValidWasmType(param.Type(), siteParam) {
+		if !isValidWasmType(param.Type(), false) {
 			c.addError(param.Pos(), fmt.Sprintf("%s: unsupported parameter type %s", pragma, param.Type().String()))
 		}
 	}
 }
 
-// Check whether the type maps directly to a WebAssembly type.
-//
-// This reflects the relaxed type restrictions proposed here (except for structs.HostLayout):
-// https://github.com/golang/go/issues/66984
-//
-// This previously reflected the additional restrictions documented here:
+// Check whether the type maps directly to a WebAssembly type, according to:
 // https://github.com/golang/go/issues/59149
-func isValidWasmType(typ types.Type, site wasmSite) bool {
+func isValidWasmType(typ types.Type, isReturn bool) bool {
 	switch typ := typ.Underlying().(type) {
 	case *types.Basic:
 		switch typ.Kind() {
-		case types.Bool:
-			return true
-		case types.Int, types.Uint, types.Int8, types.Uint8, types.Int16, types.Uint16, types.Int32, types.Uint32, types.Int64, types.Uint64:
+		case types.Int32, types.Uint32, types.Int64, types.Uint64:
 			return true
 		case types.Float32, types.Float64:
 			return true
-		case types.Uintptr, types.UnsafePointer:
-			return true
-		case types.String:
-			// string flattens to two values, so disallowed as a result
-			return site == siteParam || site == siteIndirect
-		}
-	case *types.Array:
-		return site == siteIndirect && isValidWasmType(typ.Elem(), siteIndirect)
-	case *types.Struct:
-		if site != siteIndirect {
-			return false
-		}
-		for i := 0; i < typ.NumFields(); i++ {
-			if !isValidWasmType(typ.Field(i).Type(), siteIndirect) {
-				return false
+		case types.UnsafePointer:
+			if !isReturn {
+				return true
 			}
 		}
-		return true
-	case *types.Pointer:
-		return isValidWasmType(typ.Elem(), siteIndirect)
 	}
 	return false
 }
 
-type wasmSite int
-
-const (
-	siteParam wasmSite = iota
-	siteResult
-	siteIndirect // pointer or field
-)
-
 // getParams returns the function parameters, including the receiver at the
 // start. This is an alternative to the Params member of *ssa.Function, which is
 // not yet populated when the package has not yet been built.

compiler/testdata/errors.go

@@ -13,65 +13,31 @@ func implementation() {
 
 type Uint uint32
 
-type S struct {
-	a [4]uint32
-	b uintptr
-	c int
-	d float32
-	e float64
-}
-
 //go:wasmimport modulename validparam
-func validparam(a int32, b uint64, c float64, d unsafe.Pointer, e Uint, f uintptr, g string, h *int32, i *S)
+func validparam(a int32, b uint64, c float64, d unsafe.Pointer, e Uint)
 
-// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type [4]uint32
+// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type int
+// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type string
 // ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type []byte
-// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type struct{a int}
-// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type chan struct{}
-// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type func()
+// ERROR: //go:wasmimport modulename invalidparam: unsupported parameter type *int32
 //
 //go:wasmimport modulename invalidparam
-func invalidparam(a [4]uint32, b []byte, c struct{ a int }, d chan struct{}, e func())
+func invalidparam(a int, b string, c []byte, d *int32)
 
-//go:wasmimport modulename validreturn_int32
-func validreturn_int32() int32
-
-//go:wasmimport modulename validreturn_int
-func validreturn_int() int
-
-//go:wasmimport modulename validreturn_ptr_int32
-func validreturn_ptr_int32() *int32
-
-//go:wasmimport modulename validreturn_ptr_string
-func validreturn_ptr_string() *string
-
-//go:wasmimport modulename validreturn_ptr_struct
-func validreturn_ptr_struct() *S
-
-//go:wasmimport modulename validreturn_unsafe_pointer
-func validreturn_unsafe_pointer() unsafe.Pointer
+//go:wasmimport modulename validreturn
+func validreturn() int32
 
 // ERROR: //go:wasmimport modulename manyreturns: too many return values
 //
 //go:wasmimport modulename manyreturns
 func manyreturns() (int32, int32)
 
-// ERROR: //go:wasmimport modulename invalidreturn_func: unsupported result type func()
+// ERROR: //go:wasmimport modulename invalidreturn: unsupported result type int
 //
-//go:wasmimport modulename invalidreturn_func
-func invalidreturn_func() func()
+//go:wasmimport modulename invalidreturn
+func invalidreturn() int
 
-// ERROR: //go:wasmimport modulename invalidreturn_slice_byte: unsupported result type []byte
+// ERROR: //go:wasmimport modulename invalidUnsafePointerReturn: unsupported result type unsafe.Pointer
 //
-//go:wasmimport modulename invalidreturn_slice_byte
-func invalidreturn_slice_byte() []byte
-
-// ERROR: //go:wasmimport modulename invalidreturn_chan_int: unsupported result type chan int
-//
-//go:wasmimport modulename invalidreturn_chan_int
-func invalidreturn_chan_int() chan int
-
-// ERROR: //go:wasmimport modulename invalidreturn_string: unsupported result type string
-//
-//go:wasmimport modulename invalidreturn_string
-func invalidreturn_string() string
+//go:wasmimport modulename invalidUnsafePointerReturn
+func invalidUnsafePointerReturn() unsafe.Pointer

compiler/testdata/gc.ll

@@ -39,16 +39,16 @@ entry:
 define hidden void @main.newScalar(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call align 1 dereferenceable(1) ptr @runtime.alloc(i32 1, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new = call dereferenceable(1) ptr @runtime.alloc(i32 1, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.scalar1, align 4
-  %new1 = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new1 = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new1, ptr @main.scalar2, align 4
-  %new2 = call align 8 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new2 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.scalar3, align 4
-  %new3 = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new3 = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new3, ptr @main.scalar4, align 4
   ret void
@@ -58,13 +58,13 @@ entry:
 define hidden void @main.newArray(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call align 1 dereferenceable(3) ptr @runtime.alloc(i32 3, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new = call dereferenceable(3) ptr @runtime.alloc(i32 3, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.array1, align 4
-  %new1 = call align 1 dereferenceable(71) ptr @runtime.alloc(i32 71, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new1 = call dereferenceable(71) ptr @runtime.alloc(i32 71, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new1, ptr @main.array2, align 4
-  %new2 = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
+  %new2 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.array3, align 4
   ret void
@@ -74,16 +74,16 @@ entry:
 define hidden void @main.newStruct(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call align 1 ptr @runtime.alloc(i32 0, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new = call ptr @runtime.alloc(i32 0, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new, ptr @main.struct1, align 4
-  %new1 = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %new1 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new1, ptr @main.struct2, align 4
-  %new2 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-2000000000000001", ptr undef) #3
+  %new2 = call dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-2000000000000001", ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new2, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new2, ptr @main.struct3, align 4
-  %new3 = call align 4 dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0001", ptr undef) #3
+  %new3 = call dereferenceable(248) ptr @runtime.alloc(i32 248, ptr nonnull @"runtime/gc.layout:62-0001", ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %new3, ptr @main.struct4, align 4
   ret void
@@ -93,7 +93,7 @@ entry:
 define hidden ptr @main.newFuncValue(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %new = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 197 to ptr), ptr undef) #3
+  %new = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr nonnull inttoptr (i32 197 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %new, ptr nonnull %stackalloc, ptr undef) #3
   ret ptr %new
 }
@@ -102,17 +102,17 @@ entry:
 define hidden void @main.makeSlice(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %makeslice = call align 1 dereferenceable(5) ptr @runtime.alloc(i32 5, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice = call dereferenceable(5) ptr @runtime.alloc(i32 5, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice, ptr @main.slice1, align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice1, i32 0, i32 1), align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice1, i32 0, i32 2), align 4
-  %makeslice1 = call align 4 dereferenceable(20) ptr @runtime.alloc(i32 20, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
+  %makeslice1 = call dereferenceable(20) ptr @runtime.alloc(i32 20, ptr nonnull inttoptr (i32 67 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %makeslice1, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice1, ptr @main.slice2, align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice2, i32 0, i32 1), align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice2, i32 0, i32 2), align 4
-  %makeslice3 = call align 4 dereferenceable(60) ptr @runtime.alloc(i32 60, ptr nonnull inttoptr (i32 71 to ptr), ptr undef) #3
+  %makeslice3 = call dereferenceable(60) ptr @runtime.alloc(i32 60, ptr nonnull inttoptr (i32 71 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %makeslice3, ptr nonnull %stackalloc, ptr undef) #3
   store ptr %makeslice3, ptr @main.slice3, align 4
   store i32 5, ptr getelementptr inbounds ({ ptr, i32, i32 }, ptr @main.slice3, i32 0, i32 1), align 4
@@ -124,7 +124,7 @@ entry:
 define hidden %runtime._interface @main.makeInterface(double %v.r, double %v.i, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call align 8 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #3
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #3
   store double %v.r, ptr %0, align 8
   %.repack1 = getelementptr inbounds { double, double }, ptr %0, i32 0, i32 1

compiler/testdata/goroutine-cortex-m-qemu-tasks.ll

@@ -63,9 +63,9 @@ entry:
 ; Function Attrs: nounwind
 define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #1 {
 entry:
-  %n = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
+  %n = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
   store i32 3, ptr %n, align 4
-  %0 = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
+  %0 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
   store ptr %n, ptr %1, align 4
@@ -98,7 +98,7 @@ declare void @runtime.printint32(i32, ptr) #2
 ; Function Attrs: nounwind
 define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
+  %0 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
   store ptr %fn.context, ptr %1, align 4
@@ -148,7 +148,7 @@ declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #2
 ; Function Attrs: nounwind
 define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #1 {
 entry:
-  %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
   %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1
   store ptr @"main$string", ptr %1, align 4

compiler/testdata/goroutine-wasm-asyncify.ll

@@ -66,12 +66,12 @@ entry:
 define hidden void @main.closureFunctionGoroutine(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %n = call align 4 dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
+  %n = call dereferenceable(4) ptr @runtime.alloc(i32 4, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #9
   store i32 3, ptr %n, align 4
   call void @runtime.trackPointer(ptr nonnull %n, ptr nonnull %stackalloc, ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull @"main.closureFunctionGoroutine$1", ptr nonnull %stackalloc, ptr undef) #9
-  %0 = call align 4 dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
+  %0 = call dereferenceable(8) ptr @runtime.alloc(i32 8, ptr null, ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr }, ptr %0, i32 0, i32 1
@@ -106,7 +106,7 @@ declare void @runtime.printint32(i32, ptr) #1
 define hidden void @main.funcGoroutine(ptr %fn.context, ptr %fn.funcptr, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
+  %0 = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr null, ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store i32 5, ptr %0, align 4
   %1 = getelementptr inbounds { i32, ptr, ptr }, ptr %0, i32 0, i32 1
@@ -158,7 +158,7 @@ declare void @runtime.chanClose(ptr dereferenceable_or_null(32), ptr) #1
 define hidden void @main.startInterfaceMethod(ptr %itf.typecode, ptr %itf.value, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %0 = call align 4 dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
+  %0 = call dereferenceable(16) ptr @runtime.alloc(i32 16, ptr null, ptr undef) #9
   call void @runtime.trackPointer(ptr nonnull %0, ptr nonnull %stackalloc, ptr undef) #9
   store ptr %itf.value, ptr %0, align 4
   %1 = getelementptr inbounds { ptr, %runtime._string, ptr }, ptr %0, i32 0, i32 1

compiler/testdata/slice.ll

@@ -48,7 +48,7 @@ declare void @runtime.lookupPanic(ptr) #1
 define hidden { ptr, i32, i32 } @main.sliceAppendValues(ptr %ints.data, i32 %ints.len, i32 %ints.cap, ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %varargs = call align 4 dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %varargs = call dereferenceable(12) ptr @runtime.alloc(i32 12, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %varargs, ptr nonnull %stackalloc, ptr undef) #3
   store i32 1, ptr %varargs, align 4
   %0 = getelementptr inbounds [3 x i32], ptr %varargs, i32 0, i32 1
@@ -100,7 +100,7 @@ entry:
   br i1 %slice.maxcap, label %slice.throw, label %slice.next
 
 slice.next:                                       ; preds = %entry
-  %makeslice.buf = call align 1 ptr @runtime.alloc(i32 %len, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice.buf = call ptr @runtime.alloc(i32 %len, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
@@ -123,7 +123,7 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl nuw i32 %len, 1
-  %makeslice.buf = call align 2 ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
@@ -144,7 +144,7 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = mul i32 %len, 3
-  %makeslice.buf = call align 1 ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
@@ -165,7 +165,7 @@ entry:
 
 slice.next:                                       ; preds = %entry
   %makeslice.cap = shl nuw i32 %len, 2
-  %makeslice.buf = call align 4 ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice.buf = call ptr @runtime.alloc(i32 %makeslice.cap, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   %0 = insertvalue { ptr, i32, i32 } undef, ptr %makeslice.buf, 0
   %1 = insertvalue { ptr, i32, i32 } %0, i32 %len, 1
   %2 = insertvalue { ptr, i32, i32 } %1, i32 %len, 2
@@ -216,7 +216,7 @@ declare void @runtime.sliceToArrayPointerPanic(ptr) #1
 define hidden ptr @main.SliceToArrayConst(ptr %context) unnamed_addr #2 {
 entry:
   %stackalloc = alloca i8, align 1
-  %makeslice = call align 4 dereferenceable(24) ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
+  %makeslice = call dereferenceable(24) ptr @runtime.alloc(i32 24, ptr nonnull inttoptr (i32 3 to ptr), ptr undef) #3
   call void @runtime.trackPointer(ptr nonnull %makeslice, ptr nonnull %stackalloc, ptr undef) #3
   br i1 false, label %slicetoarray.throw, label %slicetoarray.next
 

diff.go

@@ -1,261 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"sort"
-	"strings"
-)
-
-// A pair is a pair of values tracked for both the x and y side of a diff.
-// It is typically a pair of line indexes.
-type pair struct{ x, y int }
-
-// Diff returns an anchored diff of the two texts old and new
-// in the “unified diff” format. If old and new are identical,
-// Diff returns a nil slice (no output).
-//
-// Unix diff implementations typically look for a diff with
-// the smallest number of lines inserted and removed,
-// which can in the worst case take time quadratic in the
-// number of lines in the texts. As a result, many implementations
-// either can be made to run for a long time or cut off the search
-// after a predetermined amount of work.
-//
-// In contrast, this implementation looks for a diff with the
-// smallest number of “unique” lines inserted and removed,
-// where unique means a line that appears just once in both old and new.
-// We call this an “anchored diff” because the unique lines anchor
-// the chosen matching regions. An anchored diff is usually clearer
-// than a standard diff, because the algorithm does not try to
-// reuse unrelated blank lines or closing braces.
-// The algorithm also guarantees to run in O(n log n) time
-// instead of the standard O(n²) time.
-//
-// Some systems call this approach a “patience diff,” named for
-// the “patience sorting” algorithm, itself named for a solitaire card game.
-// We avoid that name for two reasons. First, the name has been used
-// for a few different variants of the algorithm, so it is imprecise.
-// Second, the name is frequently interpreted as meaning that you have
-// to wait longer (to be patient) for the diff, meaning that it is a slower algorithm,
-// when in fact the algorithm is faster than the standard one.
-func Diff(oldName string, old []byte, newName string, new []byte) []byte {
-	if bytes.Equal(old, new) {
-		return nil
-	}
-	x := lines(old)
-	y := lines(new)
-
-	// Print diff header.
-	var out bytes.Buffer
-	fmt.Fprintf(&out, "diff %s %s\n", oldName, newName)
-	fmt.Fprintf(&out, "--- %s\n", oldName)
-	fmt.Fprintf(&out, "+++ %s\n", newName)
-
-	// Loop over matches to consider,
-	// expanding each match to include surrounding lines,
-	// and then printing diff chunks.
-	// To avoid setup/teardown cases outside the loop,
-	// tgs returns a leading {0,0} and trailing {len(x), len(y)} pair
-	// in the sequence of matches.
-	var (
-		done  pair     // printed up to x[:done.x] and y[:done.y]
-		chunk pair     // start lines of current chunk
-		count pair     // number of lines from each side in current chunk
-		ctext []string // lines for current chunk
-	)
-	for _, m := range tgs(x, y) {
-		if m.x < done.x {
-			// Already handled scanning forward from earlier match.
-			continue
-		}
-
-		// Expand matching lines as far as possible,
-		// establishing that x[start.x:end.x] == y[start.y:end.y].
-		// Note that on the first (or last) iteration we may (or definitely do)
-		// have an empty match: start.x==end.x and start.y==end.y.
-		start := m
-		for start.x > done.x && start.y > done.y && x[start.x-1] == y[start.y-1] {
-			start.x--
-			start.y--
-		}
-		end := m
-		for end.x < len(x) && end.y < len(y) && x[end.x] == y[end.y] {
-			end.x++
-			end.y++
-		}
-
-		// Emit the mismatched lines before start into this chunk.
-		// (No effect on first sentinel iteration, when start = {0,0}.)
-		for _, s := range x[done.x:start.x] {
-			ctext = append(ctext, "-"+s)
-			count.x++
-		}
-		for _, s := range y[done.y:start.y] {
-			ctext = append(ctext, "+"+s)
-			count.y++
-		}
-
-		// If we're not at EOF and have too few common lines,
-		// the chunk includes all the common lines and continues.
-		const C = 3 // number of context lines
-		if (end.x < len(x) || end.y < len(y)) &&
-			(end.x-start.x < C || (len(ctext) > 0 && end.x-start.x < 2*C)) {
-			for _, s := range x[start.x:end.x] {
-				ctext = append(ctext, " "+s)
-				count.x++
-				count.y++
-			}
-			done = end
-			continue
-		}
-
-		// End chunk with common lines for context.
-		if len(ctext) > 0 {
-			n := end.x - start.x
-			if n > C {
-				n = C
-			}
-			for _, s := range x[start.x : start.x+n] {
-				ctext = append(ctext, " "+s)
-				count.x++
-				count.y++
-			}
-			done = pair{start.x + n, start.y + n}
-
-			// Format and emit chunk.
-			// Convert line numbers to 1-indexed.
-			// Special case: empty file shows up as 0,0 not 1,0.
-			if count.x > 0 {
-				chunk.x++
-			}
-			if count.y > 0 {
-				chunk.y++
-			}
-			fmt.Fprintf(&out, "@@ -%d,%d +%d,%d @@\n", chunk.x, count.x, chunk.y, count.y)
-			for _, s := range ctext {
-				out.WriteString(s)
-			}
-			count.x = 0
-			count.y = 0
-			ctext = ctext[:0]
-		}
-
-		// If we reached EOF, we're done.
-		if end.x >= len(x) && end.y >= len(y) {
-			break
-		}
-
-		// Otherwise start a new chunk.
-		chunk = pair{end.x - C, end.y - C}
-		for _, s := range x[chunk.x:end.x] {
-			ctext = append(ctext, " "+s)
-			count.x++
-			count.y++
-		}
-		done = end
-	}
-
-	return out.Bytes()
-}
-
-// lines returns the lines in the file x, including newlines.
-// If the file does not end in a newline, one is supplied
-// along with a warning about the missing newline.
-func lines(x []byte) []string {
-	l := strings.SplitAfter(string(x), "\n")
-	if l[len(l)-1] == "" {
-		l = l[:len(l)-1]
-	} else {
-		// Treat last line as having a message about the missing newline attached,
-		// using the same text as BSD/GNU diff (including the leading backslash).
-		l[len(l)-1] += "\n\\ No newline at end of file\n"
-	}
-	return l
-}
-
-// tgs returns the pairs of indexes of the longest common subsequence
-// of unique lines in x and y, where a unique line is one that appears
-// once in x and once in y.
-//
-// The longest common subsequence algorithm is as described in
-// Thomas G. Szymanski, “A Special Case of the Maximal Common
-// Subsequence Problem,” Princeton TR #170 (January 1975),
-// available at https://research.swtch.com/tgs170.pdf.
-func tgs(x, y []string) []pair {
-	// Count the number of times each string appears in a and b.
-	// We only care about 0, 1, many, counted as 0, -1, -2
-	// for the x side and 0, -4, -8 for the y side.
-	// Using negative numbers now lets us distinguish positive line numbers later.
-	m := make(map[string]int)
-	for _, s := range x {
-		if c := m[s]; c > -2 {
-			m[s] = c - 1
-		}
-	}
-	for _, s := range y {
-		if c := m[s]; c > -8 {
-			m[s] = c - 4
-		}
-	}
-
-	// Now unique strings can be identified by m[s] = -1+-4.
-	//
-	// Gather the indexes of those strings in x and y, building:
-	//	xi[i] = increasing indexes of unique strings in x.
-	//	yi[i] = increasing indexes of unique strings in y.
-	//	inv[i] = index j such that x[xi[i]] = y[yi[j]].
-	var xi, yi, inv []int
-	for i, s := range y {
-		if m[s] == -1+-4 {
-			m[s] = len(yi)
-			yi = append(yi, i)
-		}
-	}
-	for i, s := range x {
-		if j, ok := m[s]; ok && j >= 0 {
-			xi = append(xi, i)
-			inv = append(inv, j)
-		}
-	}
-
-	// Apply Algorithm A from Szymanski's paper.
-	// In those terms, A = J = inv and B = [0, n).
-	// We add sentinel pairs {0,0}, and {len(x),len(y)}
-	// to the returned sequence, to help the processing loop.
-	J := inv
-	n := len(xi)
-	T := make([]int, n)
-	L := make([]int, n)
-	for i := range T {
-		T[i] = n + 1
-	}
-	for i := 0; i < n; i++ {
-		k := sort.Search(n, func(k int) bool {
-			return T[k] >= J[i]
-		})
-		T[k] = J[i]
-		L[i] = k + 1
-	}
-	k := 0
-	for _, v := range L {
-		if k < v {
-			k = v
-		}
-	}
-	seq := make([]pair, 2+k)
-	seq[1+k] = pair{len(x), len(y)} // sentinel at end
-	lastj := n
-	for i := n - 1; i >= 0; i-- {
-		if L[i] == k && J[i] < lastj {
-			seq[k] = pair{xi[i], yi[J[i]]}
-			k--
-		}
-	}
-	seq[0] = pair{0, 0} // sentinel at start
-	return seq
-}

errors_test.go

@@ -1,101 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/tinygo-org/tinygo/compileopts"
-)
-
-// Test the error messages of the TinyGo compiler.
-func TestErrors(t *testing.T) {
-	for _, name := range []string{
-		"cgo",
-		"multi",
-		"loader-importcycle",
-		"loader-invaliddep",
-		"loader-invalidpackage",
-		"loader-nopackage",
-		"syntax",
-		"types",
-	} {
-		t.Run(name, func(t *testing.T) {
-			testErrorMessages(t, "./testdata/errors/"+name+".go")
-		})
-	}
-}
-
-func testErrorMessages(t *testing.T, filename string) {
-	// Parse expected error messages.
-	expected := readErrorMessages(t, filename)
-
-	// Try to build a binary (this should fail with an error).
-	tmpdir := t.TempDir()
-	err := Build(filename, tmpdir+"/out", &compileopts.Options{
-		Target:        "wasip1",
-		Semaphore:     sema,
-		InterpTimeout: 180 * time.Second,
-		Debug:         true,
-		VerifyIR:      true,
-		Opt:           "z",
-	})
-	if err == nil {
-		t.Fatal("expected to get a compiler error")
-	}
-
-	// Get the full ./testdata/errors directory.
-	wd, absErr := filepath.Abs("testdata/errors")
-	if absErr != nil {
-		t.Fatal(absErr)
-	}
-
-	// Write error message out as plain text.
-	var buf bytes.Buffer
-	printCompilerError(err, func(v ...interface{}) {
-		fmt.Fprintln(&buf, v...)
-	}, wd)
-	actual := strings.TrimRight(buf.String(), "\n")
-
-	// Check whether the error is as expected.
-	if canonicalizeErrors(actual) != canonicalizeErrors(expected) {
-		t.Errorf("expected error:\n%s\ngot:\n%s", indentText(expected, "> "), indentText(actual, "> "))
-	}
-}
-
-func canonicalizeErrors(text string) string {
-	// Fix for Windows: replace all backslashes with forward slashes so that
-	// paths will be the same as on POSIX systems.
-	// (It may also change some other backslashes, but since this is only for
-	// comparing text it should be fine).
-	if runtime.GOOS == "windows" {
-		text = strings.ReplaceAll(text, "\\", "/")
-	}
-	return text
-}
-
-// Indent the given text with a given indentation string.
-func indentText(text, indent string) string {
-	return indent + strings.ReplaceAll(text, "\n", "\n"+indent)
-}
-
-// Read "// ERROR:" prefixed messages from the given file.
-func readErrorMessages(t *testing.T, file string) string {
-	data, err := os.ReadFile(file)
-	if err != nil {
-		t.Fatal("could not read input file:", err)
-	}
-
-	var errors []string
-	for _, line := range strings.Split(string(data), "\n") {
-		if strings.HasPrefix(line, "// ERROR: ") {
-			errors = append(errors, strings.TrimRight(line[len("// ERROR: "):], "\r\n"))
-		}
-	}
-	return strings.Join(errors, "\n")
-}

go.mod

@@ -21,7 +21,7 @@ require (
 	golang.org/x/sys v0.21.0
 	golang.org/x/tools v0.22.1-0.20240621165957-db513b091504
 	gopkg.in/yaml.v2 v2.4.0
-	tinygo.org/x/go-llvm v0.0.0-20240627184919-3b50c76783a8
+	tinygo.org/x/go-llvm v0.0.0-20240518103902-697964f2a9dc
 )
 
 require (

go.sum

@@ -106,5 +106,5 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
 gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
-tinygo.org/x/go-llvm v0.0.0-20240627184919-3b50c76783a8 h1:bLsZXRUBavt++CJlMN7sppNziqu3LyamESLhFJcpqFQ=
-tinygo.org/x/go-llvm v0.0.0-20240627184919-3b50c76783a8/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=
+tinygo.org/x/go-llvm v0.0.0-20240518103902-697964f2a9dc h1:TCzibFa4oLu+njEP3fnRUmZ+QQeb8BjtOwctgcjzL0k=
+tinygo.org/x/go-llvm v0.0.0-20240518103902-697964f2a9dc/go.mod h1:GFbusT2VTA4I+l4j80b17KFK+6whv69Wtny5U+T8RR0=

goenv/goenv.go

@@ -159,11 +159,6 @@ func Get(name string) string {
 		}
 
 		return findWasmOpt()
-	case "WASMTOOLS":
-		if path := os.Getenv("WASMTOOLS"); path != "" {
-			return path
-		}
-		return "wasm-tools"
 	default:
 		return ""
 	}

loader/goroot.go

@@ -241,7 +241,6 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"internal/fuzz/":        false,
 		"internal/reflectlite/": false,
 		"internal/task/":        false,
-		"internal/wasi/":        false,
 		"machine/":              false,
 		"net/":                  true,
 		"net/http/":             false,
@@ -251,8 +250,6 @@ func pathsToOverride(goMinor int, needsSyscallPackage bool) map[string]bool {
 		"runtime/":              false,
 		"sync/":                 true,
 		"testing/":              true,
-		"vendor/":               true,
-		"vendor/github.com/":    false,
 	}
 
 	if goMinor >= 19 {

loader/loader.go

@@ -128,7 +128,7 @@ func Load(config *compileopts.Config, inputPkg string, typeChecker types.Config)
 	}
 
 	// List the dependencies of this package, in raw JSON format.
-	extraArgs := []string{"-json", "-deps", "-e"}
+	extraArgs := []string{"-json", "-deps"}
 	if config.TestConfig.CompileTestBinary {
 		extraArgs = append(extraArgs, "-test")
 	}
@@ -149,7 +149,6 @@ func Load(config *compileopts.Config, inputPkg string, typeChecker types.Config)
 
 	// Parse the returned json from `go list`.
 	decoder := json.NewDecoder(buf)
-	var pkgErrors []error
 	for {
 		pkg := &Package{
 			program:      p,
@@ -189,12 +188,6 @@ func Load(config *compileopts.Config, inputPkg string, typeChecker types.Config)
 					pos.Filename = strings.Join(fields[:len(fields)-1], ":")
 					pos.Line, _ = strconv.Atoi(fields[len(fields)-1])
 				}
-				if abs, err := filepath.Abs(pos.Filename); err == nil {
-					// Make the path absolute, so that error messages will be
-					// prettier (it will be turned back into a relative path
-					// when printing the error).
-					pos.Filename = abs
-				}
 				pos.Filename = p.getOriginalPath(pos.Filename)
 			}
 			err := scanner.Error{
@@ -202,11 +195,10 @@ func Load(config *compileopts.Config, inputPkg string, typeChecker types.Config)
 				Msg: pkg.Error.Err,
 			}
 			if len(pkg.Error.ImportStack) != 0 {
-				pkgErrors = append(pkgErrors, Error{
+				return nil, Error{
 					ImportStack: pkg.Error.ImportStack,
 					Err:         err,
-				})
-				continue
+				}
 			}
 			return nil, err
 		}
@@ -249,13 +241,6 @@ func Load(config *compileopts.Config, inputPkg string, typeChecker types.Config)
 		p.Packages[pkg.ImportPath] = pkg
 	}
 
-	if len(pkgErrors) != 0 {
-		// TODO: use errors.Join in Go 1.20.
-		return nil, Errors{
-			Errs: pkgErrors,
-		}
-	}
-
 	if config.TestConfig.CompileTestBinary && !strings.HasSuffix(p.sorted[len(p.sorted)-1].ImportPath, ".test") {
 		// Trying to compile a test binary but there are no test files in this
 		// package.
@@ -318,34 +303,18 @@ func (p *Program) MainPkg() *Package {
 func (p *Program) Parse() error {
 	// Parse all packages.
 	// TODO: do this in parallel.
-	var errors []error
 	for _, pkg := range p.sorted {
 		err := pkg.Parse()
 		if err != nil {
-			errors = append(errors, err)
+			return err
 		}
 	}
 
 	// Typecheck all packages.
 	for _, pkg := range p.sorted {
-		if !pkg.isParsed() || !pkg.allImportsChecked() {
-			if len(errors) == 0 {
-				// Sanity check.
-				// If there are no errors, all packages should have been parsed.
-				panic("unreachable")
-			}
-			continue
-		}
 		err := pkg.Check()
 		if err != nil {
-			errors = append(errors, err)
-		}
-	}
-
-	if len(errors) != 0 {
-		// TODO: use errors.Join in Go 1.20.
-		return Errors{
-			Errs: errors,
+			return err
 		}
 	}
 
@@ -370,12 +339,12 @@ func (p *Package) parseFile(path string, mode parser.Mode) (*ast.File, error) {
 	return parser.ParseFile(p.program.fset, originalPath, data, mode)
 }
 
-// Parse parses this package.
+// Parse parses and typechecks this package.
 //
 // Idempotent.
 func (p *Package) Parse() error {
-	if p.isParsed() {
-		return nil // nothing to do
+	if len(p.Files) != 0 {
+		return nil // nothing to do (?)
 	}
 
 	// Load the AST.
@@ -395,24 +364,6 @@ func (p *Package) Parse() error {
 	return nil
 }
 
-// isParsed returns whether this package has been parsed.
-func (p *Package) isParsed() bool {
-	// Special case: the unsafe package doesn't have files to parse but does
-	// have p.Pkg set once it is parsed.
-	return len(p.Files) != 0 || p.Pkg != nil
-}
-
-// allImportsChecked returns whether all imports of this package have been
-// type-checked.
-func (p *Package) allImportsChecked() bool {
-	for _, dep := range p.Imports {
-		if p.program.Packages[dep].Pkg == nil {
-			return false
-		}
-	}
-	return true
-}
-
 // Check runs the package through the typechecker. The package must already be
 // loaded and all dependencies must have been checked already.
 //

main.go

@@ -306,25 +306,16 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 			// reads any files.
 			//
 			// Ex. run --dir=.. --dir=../.. --dir=../../..
-			var dirs []string
-			switch config.Options.Target {
-			case "wasip1":
-				dirs = dirsToModuleRootRel(result.MainDir, result.ModuleRoot)
-			case "wasip2":
-				dirs = dirsToModuleRootAbs(result.MainDir, result.ModuleRoot)
-			default:
-				return fmt.Errorf("unknown GOOS target: %v", config.Options.Target)
-			}
-
+			dirs := dirsToModuleRoot(result.MainDir, result.ModuleRoot)
 			args := []string{"run"}
-			for _, d := range dirs {
+			for _, d := range dirs[1:] {
 				args = append(args, "--dir="+d)
 			}
 
-			args = append(args, "--env=PWD="+cmd.Dir)
-
+			// The below re-organizes the arguments so that the current
+			// directory is added last.
 			args = append(args, cmd.Args[1:]...)
-			cmd.Args = args
+			cmd.Args = append(cmd.Args[:1:1], args...)
 		}
 
 		// Run the test.
@@ -365,8 +356,8 @@ func Test(pkgName string, stdout, stderr io.Writer, options *compileopts.Options
 	return passed, err
 }
 
-func dirsToModuleRootRel(maindir, modroot string) []string {
-	var dirs []string
+func dirsToModuleRoot(maindir, modroot string) []string {
+	var dirs = []string{"."}
 	last := ".."
 	// strip off path elements until we hit the module root
 	// adding `..`, `../..`, `../../..` until we're done
@@ -375,20 +366,6 @@ func dirsToModuleRootRel(maindir, modroot string) []string {
 		last = filepath.Join(last, "..")
 		maindir = filepath.Dir(maindir)
 	}
-	dirs = append(dirs, ".")
-	return dirs
-}
-
-func dirsToModuleRootAbs(maindir, modroot string) []string {
-	var dirs = []string{maindir}
-	last := filepath.Join(maindir, "..")
-	// strip off path elements until we hit the module root
-	// adding `..`, `../..`, `../../..` until we're done
-	for maindir != modroot {
-		dirs = append(dirs, last)
-		last = filepath.Join(last, "..")
-		maindir = filepath.Dir(maindir)
-	}
 	return dirs
 }
 
@@ -808,9 +785,6 @@ func Run(pkgName string, options *compileopts.Options, cmdArgs []string) error {
 // passes command line arguments and evironment variables in a way appropriate
 // for the given emulator.
 func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, cmdArgs, environmentVars []string, timeout time.Duration, run func(cmd *exec.Cmd, result builder.BuildResult) error) (builder.BuildResult, error) {
-
-	isSingleFile := strings.HasSuffix(pkgName, ".go")
-
 	// Determine whether we're on a system that supports environment variables
 	// and command line parameters (operating systems, WASI) or not (baremetal,
 	// WebAssembly in the browser). If we're on a system without an environment,
@@ -844,6 +818,9 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 			}
 		}
 	} else if config.EmulatorName() == "wasmtime" {
+		// Wasmtime needs some special flags to pass environment variables
+		// and allow reading from the current directory.
+		emuArgs = append(emuArgs, "--dir=.")
 		for _, v := range environmentVars {
 			emuArgs = append(emuArgs, "--env", v)
 		}
@@ -899,26 +876,7 @@ func buildAndRun(pkgName string, config *compileopts.Config, stdout io.Writer, c
 		if err != nil {
 			return result, err
 		}
-
 		name = emulator[0]
-
-		if name == "wasmtime" {
-			// Wasmtime needs some special flags to pass environment variables
-			// and allow reading from the current directory.
-			switch config.Options.Target {
-			case "wasip1":
-				emuArgs = append(emuArgs, "--dir=.")
-			case "wasip2":
-				dir := result.MainDir
-				if isSingleFile {
-					cwd, _ := os.Getwd()
-					dir = cwd
-				}
-				emuArgs = append(emuArgs, "--dir="+dir)
-				emuArgs = append(emuArgs, "--env=PWD="+dir)
-			}
-		}
-
 		emuArgs = append(emuArgs, emulator[1:]...)
 		args = append(emuArgs, args...)
 	}
@@ -1288,9 +1246,10 @@ func usage(command string) {
 
 // try to make the path relative to the current working directory. If any error
 // occurs, this error is ignored and the absolute path is returned instead.
-func tryToMakePathRelative(dir, wd string) string {
-	if wd == "" {
-		return dir // working directory not found
+func tryToMakePathRelative(dir string) string {
+	wd, err := os.Getwd()
+	if err != nil {
+		return dir
 	}
 	relpath, err := filepath.Rel(wd, dir)
 	if err != nil {
@@ -1301,25 +1260,28 @@ func tryToMakePathRelative(dir, wd string) string {
 
 // printCompilerError prints compiler errors using the provided logger function
 // (similar to fmt.Println).
-func printCompilerError(err error, logln func(...interface{}), wd string) {
+//
+// There is one exception: interp errors may print to stderr unconditionally due
+// to limitations in the LLVM bindings.
+func printCompilerError(logln func(...interface{}), err error) {
 	switch err := err.(type) {
 	case types.Error:
-		printCompilerError(scanner.Error{
+		printCompilerError(logln, scanner.Error{
 			Pos: err.Fset.Position(err.Pos),
 			Msg: err.Msg,
-		}, logln, wd)
+		})
 	case scanner.Error:
 		if !strings.HasPrefix(err.Pos.Filename, filepath.Join(goenv.Get("GOROOT"), "src")) && !strings.HasPrefix(err.Pos.Filename, filepath.Join(goenv.Get("TINYGOROOT"), "src")) {
 			// This file is not from the standard library (either the GOROOT or
 			// the TINYGOROOT). Make the path relative, for easier reading.
 			// Ignore any errors in the process (falling back to the absolute
 			// path).
-			err.Pos.Filename = tryToMakePathRelative(err.Pos.Filename, wd)
+			err.Pos.Filename = tryToMakePathRelative(err.Pos.Filename)
 		}
 		logln(err)
 	case scanner.ErrorList:
 		for _, scannerErr := range err {
-			printCompilerError(*scannerErr, logln, wd)
+			printCompilerError(logln, *scannerErr)
 		}
 	case *interp.Error:
 		logln("#", err.ImportPath)
@@ -1335,35 +1297,19 @@ func printCompilerError(err error, logln func(...interface{}), wd string) {
 			}
 		}
 	case loader.Errors:
-		// Parser errors, typechecking errors, or `go list` errors.
-		// err.Pkg is nil for `go list` errors.
-		if err.Pkg != nil {
-			logln("#", err.Pkg.ImportPath)
-		}
+		logln("#", err.Pkg.ImportPath)
 		for _, err := range err.Errs {
-			printCompilerError(err, logln, wd)
+			printCompilerError(logln, err)
 		}
 	case loader.Error:
-		if err.Err.Pos.Filename != "" {
-			// Probably a syntax error in a dependency.
-			printCompilerError(err.Err, logln, wd)
-		} else {
-			// Probably an "import cycle not allowed" error.
-			logln("package", err.ImportStack[0])
-			for i := 1; i < len(err.ImportStack); i++ {
-				pkgPath := err.ImportStack[i]
-				if i == len(err.ImportStack)-1 {
-					// last package
-					logln("\timports", pkgPath+": "+err.Err.Error())
-				} else {
-					// not the last pacakge
-					logln("\timports", pkgPath)
-				}
-			}
+		logln(err.Err.Error())
+		logln("package", err.ImportStack[0])
+		for _, pkgPath := range err.ImportStack[1:] {
+			logln("\timports", pkgPath)
 		}
 	case *builder.MultiError:
 		for _, err := range err.Errs {
-			printCompilerError(err, logln, wd)
+			printCompilerError(logln, err)
 		}
 	default:
 		logln("error:", err)
@@ -1371,14 +1317,10 @@ func printCompilerError(err error, logln func(...interface{}), wd string) {
 }
 
 func handleCompilerError(err error) {
-	wd, getwdErr := os.Getwd()
-	if getwdErr != nil {
-		wd = ""
-	}
 	if err != nil {
-		printCompilerError(err, func(args ...interface{}) {
+		printCompilerError(func(args ...interface{}) {
 			fmt.Fprintln(os.Stderr, args...)
-		}, wd)
+		}, err)
 		os.Exit(1)
 	}
 }
@@ -1523,12 +1465,6 @@ func main() {
 		flag.StringVar(&outpath, "o", "", "output filename")
 	}
 
-	var witPackage, witWorld string
-	if command == "help" || command == "build" || command == "test" || command == "run" {
-		flag.StringVar(&witPackage, "wit-package", "", "wit package for wasm component embedding")
-		flag.StringVar(&witWorld, "wit-world", "", "wit world for wasm component embedding")
-	}
-
 	var testConfig compileopts.TestConfig
 	if command == "help" || command == "test" {
 		flag.BoolVar(&testConfig.CompileOnly, "c", false, "compile the test binary but do not run it")
@@ -1608,8 +1544,6 @@ func main() {
 		Monitor:         *monitor,
 		BaudRate:        *baudrate,
 		Timeout:         *timeout,
-		WITPackage:      witPackage,
-		WITWorld:        witWorld,
 	}
 	if *printCommands {
 		options.PrintCommands = printCommand
@@ -1780,13 +1714,9 @@ func main() {
 				stderr := (*testStderr)(buf)
 				passed, err := Test(pkgName, stdout, stderr, options, outpath)
 				if err != nil {
-					wd, err := os.Getwd()
-					if err != nil {
-						wd = ""
-					}
-					printCompilerError(err, func(args ...interface{}) {
+					printCompilerError(func(args ...interface{}) {
 						fmt.Fprintln(stderr, args...)
-					}, wd)
+					}, err)
 				}
 				if !passed {
 					select {

main_test.go

@@ -181,10 +181,6 @@ func TestBuild(t *testing.T) {
 			t.Parallel()
 			runPlatTests(optionsFromTarget("wasip1", sema), tests, t)
 		})
-		t.Run("WASIp2", func(t *testing.T) {
-			t.Parallel()
-			runPlatTests(optionsFromTarget("wasip2", sema), tests, t)
-		})
 	}
 }
 
@@ -239,14 +235,6 @@ func runPlatTests(options compileopts.Options, tests []string, t *testing.T) {
 			default:
 			}
 		}
-		if options.Target == "wasip2" {
-			switch name {
-			case "cgo/":
-				// waisp2 use our own libc; cgo tests fail
-				continue
-			}
-		}
-
 		name := name // redefine to avoid race condition
 		t.Run(name, func(t *testing.T) {
 			t.Parallel()
@@ -309,10 +297,6 @@ func emuCheck(t *testing.T, options compileopts.Options) {
 }
 
 func optionsFromTarget(target string, sema chan struct{}) compileopts.Options {
-	separators := strings.Count(target, "/")
-	if (separators == 1 || separators == 2) && !strings.HasSuffix(target, ".json") {
-		return optionsFromOSARCH(target, sema)
-	}
 	return compileopts.Options{
 		// GOOS/GOARCH are only used if target == ""
 		GOOS:          goenv.Get("GOOS"),
@@ -380,7 +364,7 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 		return cmd.Run()
 	})
 	if err != nil {
-		printCompilerError(err, t.Log, "")
+		printCompilerError(t.Log, err)
 		t.Fail()
 		return
 	}
@@ -409,7 +393,6 @@ func runTestWithConfig(name string, t *testing.T, options compileopts.Options, c
 		fail = true
 	} else if !bytes.Equal(expected, actual) {
 		t.Logf("output did not match (expected %d bytes, got %d bytes):", len(expected), len(actual))
-		t.Logf(string(Diff("expected", expected, "actual", actual)))
 		fail = true
 	}
 

src/crypto/rand/rand_arc4random.go

@@ -1,4 +1,4 @@
-//go:build darwin || wasip1 || wasip2 || wasm
+//go:build darwin || tinygo.wasm
 
 // This implementation of crypto/rand uses the arc4random_buf function
 // (available on both MacOS and WASI) to generate random numbers.

src/crypto/rand/rand_urandom.go

@@ -1,4 +1,4 @@
-//go:build linux && !baremetal && !wasip1 && !wasip2
+//go:build linux && !baremetal && !wasip1
 
 // This implementation of crypto/rand uses the /dev/urandom pseudo-file to
 // generate random numbers.

src/device/riscv/handleinterrupt.S

@@ -1,3 +1,6 @@
+// We don't support RV32E at the moment.
+#if !defined(__riscv_32e)
+
 #ifdef __riscv_flen
 #define NREG 48
 #define LFREG flw
@@ -128,3 +131,5 @@ handleInterruptASM:
     LREG    ra, 0*REGSIZE(sp)
     addi    sp, sp, NREG*REGSIZE
     mret
+
+#endif

src/examples/hello-wasm-unknown/main.go

@@ -3,10 +3,6 @@
 // tinygo build -size short -o hello-unknown.wasm -target wasm-unknown -gc=leaking -no-debug ./src/examples/hello-wasm-unknown/
 package main
 
-// Smoke test: make sure the fmt package can be imported (even if it isn't
-// really useful for wasm-unknown).
-import _ "os"
-
 var x int32
 
 //go:wasmimport hosted echo_i32

src/internal/task/task_stack_tinygoriscv.S

@@ -1,5 +1,8 @@
 //go:build tinygo
 
+// We don't support RV32E at the moment.
+#if !defined(__riscv_32e)
+
 .section .text.tinygo_startTask
 .global  tinygo_startTask
 .type    tinygo_startTask, %function
@@ -69,3 +72,5 @@ tinygo_swapTask:
 
     // Return into the task.
     ret
+
+#endif

src/internal/wasi/cli/v0.2.0/command/command.wit.go

@@ -1,6 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package command represents the world "wasi:cli/command@0.2.0".
-package command

src/internal/wasi/cli/v0.2.0/environment/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/environment/environment.wit.go

@@ -1,66 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package environment represents the imported interface "wasi:cli/environment@0.2.0".
-package environment
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// GetEnvironment represents the imported function "get-environment".
-//
-// Get the POSIX-style environment variables.
-//
-// Each environment variable is provided as a pair of string variable names
-// and string value.
-//
-// Morally, these are a value import, but until value imports are available
-// in the component model, this import function should return the same
-// values each time it is called.
-//
-//	get-environment: func() -> list<tuple<string, string>>
-//
-//go:nosplit
-func GetEnvironment() (result cm.List[[2]string]) {
-	wasmimport_GetEnvironment(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/environment@0.2.0 get-environment
-//go:noescape
-func wasmimport_GetEnvironment(result *cm.List[[2]string])
-
-// GetArguments represents the imported function "get-arguments".
-//
-// Get the POSIX-style arguments to the program.
-//
-//	get-arguments: func() -> list<string>
-//
-//go:nosplit
-func GetArguments() (result cm.List[string]) {
-	wasmimport_GetArguments(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/environment@0.2.0 get-arguments
-//go:noescape
-func wasmimport_GetArguments(result *cm.List[string])
-
-// InitialCWD represents the imported function "initial-cwd".
-//
-// Return a path that programs should use as their initial current working
-// directory, interpreting `.` as shorthand for this.
-//
-//	initial-cwd: func() -> option<string>
-//
-//go:nosplit
-func InitialCWD() (result cm.Option[string]) {
-	wasmimport_InitialCWD(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/environment@0.2.0 initial-cwd
-//go:noescape
-func wasmimport_InitialCWD(result *cm.Option[string])

src/internal/wasi/cli/v0.2.0/exit/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/exit/exit.wit.go

@@ -1,27 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package exit represents the imported interface "wasi:cli/exit@0.2.0".
-package exit
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// Exit represents the imported function "exit".
-//
-// Exit the current instance and any linked instances.
-//
-//	exit: func(status: result)
-//
-//go:nosplit
-func Exit(status cm.BoolResult) {
-	status0 := cm.BoolToU32(status)
-	wasmimport_Exit((uint32)(status0))
-	return
-}
-
-//go:wasmimport wasi:cli/exit@0.2.0 exit
-//go:noescape
-func wasmimport_Exit(status0 uint32)

src/internal/wasi/cli/v0.2.0/run/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/run/run.exports.go

@@ -1,19 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package run
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// Exports represents the caller-defined exports from "wasi:cli/run@0.2.0".
-var Exports struct {
-	// Run represents the caller-defined, exported function "run".
-	//
-	// Run the program.
-	//
-	//	run: func() -> result
-	Run func() (result cm.BoolResult)
-}

src/internal/wasi/cli/v0.2.0/run/run.wit.go

@@ -1,18 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package run represents the exported interface "wasi:cli/run@0.2.0".
-package run
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-//go:wasmexport wasi:cli/run@0.2.0#run
-//export wasi:cli/run@0.2.0#run
-func wasmexport_Run() (result0 uint32) {
-	result := Exports.Run()
-	result0 = cm.BoolToU32(result)
-	return
-}

src/internal/wasi/cli/v0.2.0/stderr/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stderr/stderr.wit.go

@@ -1,26 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package stderr represents the imported interface "wasi:cli/stderr@0.2.0".
-package stderr
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/streams"
-)
-
-// GetStderr represents the imported function "get-stderr".
-//
-//	get-stderr: func() -> output-stream
-//
-//go:nosplit
-func GetStderr() (result streams.OutputStream) {
-	result0 := wasmimport_GetStderr()
-	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:cli/stderr@0.2.0 get-stderr
-//go:noescape
-func wasmimport_GetStderr() (result0 uint32)

src/internal/wasi/cli/v0.2.0/stdin/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stdin/stdin.wit.go

@@ -1,26 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package stdin represents the imported interface "wasi:cli/stdin@0.2.0".
-package stdin
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/streams"
-)
-
-// GetStdin represents the imported function "get-stdin".
-//
-//	get-stdin: func() -> input-stream
-//
-//go:nosplit
-func GetStdin() (result streams.InputStream) {
-	result0 := wasmimport_GetStdin()
-	result = cm.Reinterpret[streams.InputStream]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:cli/stdin@0.2.0 get-stdin
-//go:noescape
-func wasmimport_GetStdin() (result0 uint32)

src/internal/wasi/cli/v0.2.0/stdout/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/stdout/stdout.wit.go

@@ -1,26 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package stdout represents the imported interface "wasi:cli/stdout@0.2.0".
-package stdout
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/streams"
-)
-
-// GetStdout represents the imported function "get-stdout".
-//
-//	get-stdout: func() -> output-stream
-//
-//go:nosplit
-func GetStdout() (result streams.OutputStream) {
-	result0 := wasmimport_GetStdout()
-	result = cm.Reinterpret[streams.OutputStream]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:cli/stdout@0.2.0 get-stdout
-//go:noescape
-func wasmimport_GetStdout() (result0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-input/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-input/terminal-input.wit.go

@@ -1,38 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package terminalinput represents the imported interface "wasi:cli/terminal-input@0.2.0".
-//
-// Terminal input.
-//
-// In the future, this may include functions for disabling echoing,
-// disabling input buffering so that keyboard events are sent through
-// immediately, querying supported features, and so on.
-package terminalinput
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// TerminalInput represents the imported resource "wasi:cli/terminal-input@0.2.0#terminal-input".
-//
-// The input side of a terminal.
-//
-//	resource terminal-input
-type TerminalInput cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "terminal-input".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self TerminalInput) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TerminalInputResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:cli/terminal-input@0.2.0 [resource-drop]terminal-input
-//go:noescape
-func wasmimport_TerminalInputResourceDrop(self0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-output/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-output/terminal-output.wit.go

@@ -1,38 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package terminaloutput represents the imported interface "wasi:cli/terminal-output@0.2.0".
-//
-// Terminal output.
-//
-// In the future, this may include functions for querying the terminal
-// size, being notified of terminal size changes, querying supported
-// features, and so on.
-package terminaloutput
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// TerminalOutput represents the imported resource "wasi:cli/terminal-output@0.2.0#terminal-output".
-//
-// The output side of a terminal.
-//
-//	resource terminal-output
-type TerminalOutput cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "terminal-output".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self TerminalOutput) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TerminalOutputResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:cli/terminal-output@0.2.0 [resource-drop]terminal-output
-//go:noescape
-func wasmimport_TerminalOutputResourceDrop(self0 uint32)

src/internal/wasi/cli/v0.2.0/terminal-stderr/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stderr/terminal-stderr.wit.go

@@ -1,31 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package terminalstderr represents the imported interface "wasi:cli/terminal-stderr@0.2.0".
-//
-// An interface providing an optional `terminal-output` for stderr as a
-// link-time authority.
-package terminalstderr
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
-)
-
-// GetTerminalStderr represents the imported function "get-terminal-stderr".
-//
-// If stderr is connected to a terminal, return a `terminal-output` handle
-// allowing further interaction with it.
-//
-//	get-terminal-stderr: func() -> option<terminal-output>
-//
-//go:nosplit
-func GetTerminalStderr() (result cm.Option[terminaloutput.TerminalOutput]) {
-	wasmimport_GetTerminalStderr(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/terminal-stderr@0.2.0 get-terminal-stderr
-//go:noescape
-func wasmimport_GetTerminalStderr(result *cm.Option[terminaloutput.TerminalOutput])

src/internal/wasi/cli/v0.2.0/terminal-stdin/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stdin/terminal-stdin.wit.go

@@ -1,31 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package terminalstdin represents the imported interface "wasi:cli/terminal-stdin@0.2.0".
-//
-// An interface providing an optional `terminal-input` for stdin as a
-// link-time authority.
-package terminalstdin
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	terminalinput "internal/wasi/cli/v0.2.0/terminal-input"
-)
-
-// GetTerminalStdin represents the imported function "get-terminal-stdin".
-//
-// If stdin is connected to a terminal, return a `terminal-input` handle
-// allowing further interaction with it.
-//
-//	get-terminal-stdin: func() -> option<terminal-input>
-//
-//go:nosplit
-func GetTerminalStdin() (result cm.Option[terminalinput.TerminalInput]) {
-	wasmimport_GetTerminalStdin(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/terminal-stdin@0.2.0 get-terminal-stdin
-//go:noescape
-func wasmimport_GetTerminalStdin(result *cm.Option[terminalinput.TerminalInput])

src/internal/wasi/cli/v0.2.0/terminal-stdout/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/cli/v0.2.0/terminal-stdout/terminal-stdout.wit.go

@@ -1,31 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package terminalstdout represents the imported interface "wasi:cli/terminal-stdout@0.2.0".
-//
-// An interface providing an optional `terminal-output` for stdout as a
-// link-time authority.
-package terminalstdout
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	terminaloutput "internal/wasi/cli/v0.2.0/terminal-output"
-)
-
-// GetTerminalStdout represents the imported function "get-terminal-stdout".
-//
-// If stdout is connected to a terminal, return a `terminal-output` handle
-// allowing further interaction with it.
-//
-//	get-terminal-stdout: func() -> option<terminal-output>
-//
-//go:nosplit
-func GetTerminalStdout() (result cm.Option[terminaloutput.TerminalOutput]) {
-	wasmimport_GetTerminalStdout(&result)
-	return
-}
-
-//go:wasmimport wasi:cli/terminal-stdout@0.2.0 get-terminal-stdout
-//go:noescape
-func wasmimport_GetTerminalStdout(result *cm.Option[terminaloutput.TerminalOutput])

src/internal/wasi/clocks/v0.2.0/monotonic-clock/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/clocks/v0.2.0/monotonic-clock/monotonic-clock.wit.go

@@ -1,115 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package monotonicclock represents the imported interface "wasi:clocks/monotonic-clock@0.2.0".
-//
-// WASI Monotonic Clock is a clock API intended to let users measure elapsed
-// time.
-//
-// It is intended to be portable at least between Unix-family platforms and
-// Windows.
-//
-// A monotonic clock is a clock which has an unspecified initial value, and
-// successive reads of the clock will produce non-decreasing values.
-//
-// It is intended for measuring elapsed time.
-package monotonicclock
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/poll"
-)
-
-// Instant represents the u64 "wasi:clocks/monotonic-clock@0.2.0#instant".
-//
-// An instant in time, in nanoseconds. An instant is relative to an
-// unspecified initial value, and can only be compared to instances from
-// the same monotonic-clock.
-//
-//	type instant = u64
-type Instant uint64
-
-// Duration represents the u64 "wasi:clocks/monotonic-clock@0.2.0#duration".
-//
-// A duration of time, in nanoseconds.
-//
-//	type duration = u64
-type Duration uint64
-
-// Now represents the imported function "now".
-//
-// Read the current value of the clock.
-//
-// The clock is monotonic, therefore calling this function repeatedly will
-// produce a sequence of non-decreasing values.
-//
-//	now: func() -> instant
-//
-//go:nosplit
-func Now() (result Instant) {
-	result0 := wasmimport_Now()
-	result = (Instant)((uint64)(result0))
-	return
-}
-
-//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 now
-//go:noescape
-func wasmimport_Now() (result0 uint64)
-
-// Resolution represents the imported function "resolution".
-//
-// Query the resolution of the clock. Returns the duration of time
-// corresponding to a clock tick.
-//
-//	resolution: func() -> duration
-//
-//go:nosplit
-func Resolution() (result Duration) {
-	result0 := wasmimport_Resolution()
-	result = (Duration)((uint64)(result0))
-	return
-}
-
-//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 resolution
-//go:noescape
-func wasmimport_Resolution() (result0 uint64)
-
-// SubscribeInstant represents the imported function "subscribe-instant".
-//
-// Create a `pollable` which will resolve once the specified instant
-// occured.
-//
-//	subscribe-instant: func(when: instant) -> pollable
-//
-//go:nosplit
-func SubscribeInstant(when Instant) (result poll.Pollable) {
-	when0 := (uint64)(when)
-	result0 := wasmimport_SubscribeInstant((uint64)(when0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-instant
-//go:noescape
-func wasmimport_SubscribeInstant(when0 uint64) (result0 uint32)
-
-// SubscribeDuration represents the imported function "subscribe-duration".
-//
-// Create a `pollable` which will resolve once the given duration has
-// elapsed, starting at the time at which this function was called.
-// occured.
-//
-//	subscribe-duration: func(when: duration) -> pollable
-//
-//go:nosplit
-func SubscribeDuration(when Duration) (result poll.Pollable) {
-	when0 := (uint64)(when)
-	result0 := wasmimport_SubscribeDuration((uint64)(when0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:clocks/monotonic-clock@0.2.0 subscribe-duration
-//go:noescape
-func wasmimport_SubscribeDuration(when0 uint64) (result0 uint32)

src/internal/wasi/clocks/v0.2.0/wall-clock/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/clocks/v0.2.0/wall-clock/wall-clock.wit.go

@@ -1,80 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package wallclock represents the imported interface "wasi:clocks/wall-clock@0.2.0".
-//
-// WASI Wall Clock is a clock API intended to let users query the current
-// time. The name "wall" makes an analogy to a "clock on the wall", which
-// is not necessarily monotonic as it may be reset.
-//
-// It is intended to be portable at least between Unix-family platforms and
-// Windows.
-//
-// A wall clock is a clock which measures the date and time according to
-// some external reference.
-//
-// External references may be reset, so this clock is not necessarily
-// monotonic, making it unsuitable for measuring elapsed time.
-//
-// It is intended for reporting the current date and time for humans.
-package wallclock
-
-// DateTime represents the record "wasi:clocks/wall-clock@0.2.0#datetime".
-//
-// A time and date in seconds plus nanoseconds.
-//
-//	record datetime {
-//		seconds: u64,
-//		nanoseconds: u32,
-//	}
-type DateTime struct {
-	Seconds     uint64
-	Nanoseconds uint32
-}
-
-// Now represents the imported function "now".
-//
-// Read the current value of the clock.
-//
-// This clock is not monotonic, therefore calling this function repeatedly
-// will not necessarily produce a sequence of non-decreasing values.
-//
-// The returned timestamps represent the number of seconds since
-// 1970-01-01T00:00:00Z, also known as [POSIX's Seconds Since the Epoch],
-// also known as [Unix Time].
-//
-// The nanoseconds field of the output is always less than 1000000000.
-//
-//	now: func() -> datetime
-//
-// [POSIX's Seconds Since the Epoch]: https://pubs.opengroup.org/onlinepubs/9699919799/xrat/V4_xbd_chap04.html#tag_21_04_16
-// [Unix Time]: https://en.wikipedia.org/wiki/Unix_time
-//
-//go:nosplit
-func Now() (result DateTime) {
-	wasmimport_Now(&result)
-	return
-}
-
-//go:wasmimport wasi:clocks/wall-clock@0.2.0 now
-//go:noescape
-func wasmimport_Now(result *DateTime)
-
-// Resolution represents the imported function "resolution".
-//
-// Query the resolution of the clock.
-//
-// The nanoseconds field of the output is always less than 1000000000.
-//
-//	resolution: func() -> datetime
-//
-//go:nosplit
-func Resolution() (result DateTime) {
-	wasmimport_Resolution(&result)
-	return
-}
-
-//go:wasmimport wasi:clocks/wall-clock@0.2.0 resolution
-//go:noescape
-func wasmimport_Resolution(result *DateTime)

src/internal/wasi/filesystem/v0.2.0/preopens/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/filesystem/v0.2.0/preopens/preopens.wit.go

@@ -1,27 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package preopens represents the imported interface "wasi:filesystem/preopens@0.2.0".
-package preopens
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/filesystem/v0.2.0/types"
-)
-
-// GetDirectories represents the imported function "get-directories".
-//
-// Return the set of preopened directories, and their path.
-//
-//	get-directories: func() -> list<tuple<descriptor, string>>
-//
-//go:nosplit
-func GetDirectories() (result cm.List[cm.Tuple[types.Descriptor, string]]) {
-	wasmimport_GetDirectories(&result)
-	return
-}
-
-//go:wasmimport wasi:filesystem/preopens@0.2.0 get-directories
-//go:noescape
-func wasmimport_GetDirectories(result *cm.List[cm.Tuple[types.Descriptor, string]])

src/internal/wasi/filesystem/v0.2.0/types/abi.go

@@ -1,53 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package types
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	wallclock "internal/wasi/clocks/v0.2.0/wall-clock"
-	"unsafe"
-)
-
-// DateTimeShape is used for storage in variant or result types.
-type DateTimeShape struct {
-	shape [unsafe.Sizeof(wallclock.DateTime{})]byte
-}
-
-// MetadataHashValueShape is used for storage in variant or result types.
-type MetadataHashValueShape struct {
-	shape [unsafe.Sizeof(MetadataHashValue{})]byte
-}
-
-// TupleListU8BoolShape is used for storage in variant or result types.
-type TupleListU8BoolShape struct {
-	shape [unsafe.Sizeof(cm.Tuple[cm.List[uint8], bool]{})]byte
-}
-
-func lower_DateTime(v wallclock.DateTime) (f0 uint64, f1 uint32) {
-	f0 = (uint64)(v.Seconds)
-	f1 = (uint32)(v.Nanoseconds)
-	return
-}
-
-func lower_NewTimestamp(v NewTimestamp) (f0 uint32, f1 uint64, f2 uint32) {
-	f0 = (uint32)(v.Tag())
-	switch f0 {
-	case 2: // timestamp
-		v1, v2 := lower_DateTime(*v.Timestamp())
-		f1 = (uint64)(v1)
-		f2 = (uint32)(v2)
-	}
-	return
-}
-
-// DescriptorStatShape is used for storage in variant or result types.
-type DescriptorStatShape struct {
-	shape [unsafe.Sizeof(DescriptorStat{})]byte
-}
-
-// OptionDirectoryEntryShape is used for storage in variant or result types.
-type OptionDirectoryEntryShape struct {
-	shape [unsafe.Sizeof(cm.Option[DirectoryEntry]{})]byte
-}

src/internal/wasi/filesystem/v0.2.0/types/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/error/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/error/error.wit.go

@@ -1,73 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package ioerror represents the imported interface "wasi:io/error@0.2.0".
-package ioerror
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// Error represents the imported resource "wasi:io/error@0.2.0#error".
-//
-// A resource which represents some error information.
-//
-// The only method provided by this resource is `to-debug-string`,
-// which provides some human-readable information about the error.
-//
-// In the `wasi:io` package, this resource is returned through the
-// `wasi:io/streams/stream-error` type.
-//
-// To provide more specific error information, other interfaces may
-// provide functions to further "downcast" this error into more specific
-// error information. For example, `error`s returned in streams derived
-// from filesystem types to be described using the filesystem's own
-// error-code type, using the function
-// `wasi:filesystem/types/filesystem-error-code`, which takes a parameter
-// `borrow<error>` and returns
-// `option<wasi:filesystem/types/error-code>`.
-//
-// The set of functions which can "downcast" an `error` into a more
-// concrete type is open.
-//
-//	resource error
-type Error cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "error".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self Error) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_ErrorResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:io/error@0.2.0 [resource-drop]error
-//go:noescape
-func wasmimport_ErrorResourceDrop(self0 uint32)
-
-// ToDebugString represents the imported method "to-debug-string".
-//
-// Returns a string that is suitable to assist humans in debugging
-// this error.
-//
-// WARNING: The returned string should not be consumed mechanically!
-// It may change across platforms, hosts, or other implementation
-// details. Parsing this string is a major platform-compatibility
-// hazard.
-//
-//	to-debug-string: func() -> string
-//
-//go:nosplit
-func (self Error) ToDebugString() (result string) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_ErrorToDebugString((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/error@0.2.0 [method]error.to-debug-string
-//go:noescape
-func wasmimport_ErrorToDebugString(self0 uint32, result *string)

src/internal/wasi/io/v0.2.0/poll/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/poll/poll.wit.go

@@ -1,110 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package poll represents the imported interface "wasi:io/poll@0.2.0".
-//
-// A poll API intended to let users wait for I/O events on multiple handles
-// at once.
-package poll
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// Pollable represents the imported resource "wasi:io/poll@0.2.0#pollable".
-//
-// `pollable` represents a single I/O event which may be ready, or not.
-//
-//	resource pollable
-type Pollable cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "pollable".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self Pollable) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_PollableResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:io/poll@0.2.0 [resource-drop]pollable
-//go:noescape
-func wasmimport_PollableResourceDrop(self0 uint32)
-
-// Block represents the imported method "block".
-//
-// `block` returns immediately if the pollable is ready, and otherwise
-// blocks until ready.
-//
-// This function is equivalent to calling `poll.poll` on a list
-// containing only this pollable.
-//
-//	block: func()
-//
-//go:nosplit
-func (self Pollable) Block() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_PollableBlock((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.block
-//go:noescape
-func wasmimport_PollableBlock(self0 uint32)
-
-// Ready represents the imported method "ready".
-//
-// Return the readiness of a pollable. This function never blocks.
-//
-// Returns `true` when the pollable is ready, and `false` otherwise.
-//
-//	ready: func() -> bool
-//
-//go:nosplit
-func (self Pollable) Ready() (result bool) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_PollableReady((uint32)(self0))
-	result = cm.U32ToBool((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:io/poll@0.2.0 [method]pollable.ready
-//go:noescape
-func wasmimport_PollableReady(self0 uint32) (result0 uint32)
-
-// Poll represents the imported function "poll".
-//
-// Poll for completion on a set of pollables.
-//
-// This function takes a list of pollables, which identify I/O sources of
-// interest, and waits until one or more of the events is ready for I/O.
-//
-// The result `list<u32>` contains one or more indices of handles in the
-// argument list that is ready for I/O.
-//
-// If the list contains more elements than can be indexed with a `u32`
-// value, this function traps.
-//
-// A timeout can be implemented by adding a pollable from the
-// wasi-clocks API to the list.
-//
-// This function does not return a `result`; polling in itself does not
-// do any I/O so it doesn't fail. If any of the I/O sources identified by
-// the pollables has an error, it is indicated by marking the source as
-// being reaedy for I/O.
-//
-//	poll: func(in: list<borrow<pollable>>) -> list<u32>
-//
-//go:nosplit
-func Poll(in cm.List[Pollable]) (result cm.List[uint32]) {
-	in0, in1 := cm.LowerList(in)
-	wasmimport_Poll((*Pollable)(in0), (uint32)(in1), &result)
-	return
-}
-
-//go:wasmimport wasi:io/poll@0.2.0 poll
-//go:noescape
-func wasmimport_Poll(in0 *Pollable, in1 uint32, result *cm.List[uint32])

src/internal/wasi/io/v0.2.0/streams/abi.go

@@ -1,14 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package streams
-
-import (
-	"unsafe"
-)
-
-// StreamErrorShape is used for storage in variant or result types.
-type StreamErrorShape struct {
-	shape [unsafe.Sizeof(StreamError{})]byte
-}

src/internal/wasi/io/v0.2.0/streams/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/io/v0.2.0/streams/streams.wit.go

@@ -1,521 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package streams represents the imported interface "wasi:io/streams@0.2.0".
-//
-// WASI I/O is an I/O abstraction API which is currently focused on providing
-// stream types.
-//
-// In the future, the component model is expected to add built-in stream types;
-// when it does, they are expected to subsume this API.
-package streams
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	ioerror "internal/wasi/io/v0.2.0/error"
-	"internal/wasi/io/v0.2.0/poll"
-)
-
-// StreamError represents the imported variant "wasi:io/streams@0.2.0#stream-error".
-//
-// An error for input-stream and output-stream operations.
-//
-//	variant stream-error {
-//		last-operation-failed(error),
-//		closed,
-//	}
-type StreamError cm.Variant[uint8, ioerror.Error, ioerror.Error]
-
-// StreamErrorLastOperationFailed returns a [StreamError] of case "last-operation-failed".
-//
-// The last operation (a write or flush) failed before completion.
-//
-// More information is available in the `error` payload.
-func StreamErrorLastOperationFailed(data ioerror.Error) StreamError {
-	return cm.New[StreamError](0, data)
-}
-
-// LastOperationFailed returns a non-nil *[ioerror.Error] if [StreamError] represents the variant case "last-operation-failed".
-func (self *StreamError) LastOperationFailed() *ioerror.Error {
-	return cm.Case[ioerror.Error](self, 0)
-}
-
-// StreamErrorClosed returns a [StreamError] of case "closed".
-//
-// The stream is closed: no more input will be accepted by the
-// stream. A closed output-stream will return this error on all
-// future operations.
-func StreamErrorClosed() StreamError {
-	var data struct{}
-	return cm.New[StreamError](1, data)
-}
-
-// Closed returns true if [StreamError] represents the variant case "closed".
-func (self *StreamError) Closed() bool {
-	return self.Tag() == 1
-}
-
-// InputStream represents the imported resource "wasi:io/streams@0.2.0#input-stream".
-//
-// An input bytestream.
-//
-// `input-stream`s are *non-blocking* to the extent practical on underlying
-// platforms. I/O operations always return promptly; if fewer bytes are
-// promptly available than requested, they return the number of bytes promptly
-// available, which could even be zero. To wait for data to be available,
-// use the `subscribe` function to obtain a `pollable` which can be polled
-// for using `wasi:io/poll`.
-//
-//	resource input-stream
-type InputStream cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "input-stream".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self InputStream) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_InputStreamResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]input-stream
-//go:noescape
-func wasmimport_InputStreamResourceDrop(self0 uint32)
-
-// BlockingRead represents the imported method "blocking-read".
-//
-// Read bytes from a stream, after blocking until at least one byte can
-// be read. Except for blocking, behavior is identical to `read`.
-//
-//	blocking-read: func(len: u64) -> result<list<u8>, stream-error>
-//
-//go:nosplit
-func (self InputStream) BlockingRead(len_ uint64) (result cm.Result[cm.List[uint8], cm.List[uint8], StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_InputStreamBlockingRead((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-read
-//go:noescape
-func wasmimport_InputStreamBlockingRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
-
-// BlockingSkip represents the imported method "blocking-skip".
-//
-// Skip bytes from a stream, after blocking until at least one byte
-// can be skipped. Except for blocking behavior, identical to `skip`.
-//
-//	blocking-skip: func(len: u64) -> result<u64, stream-error>
-//
-//go:nosplit
-func (self InputStream) BlockingSkip(len_ uint64) (result cm.Result[uint64, uint64, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_InputStreamBlockingSkip((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.blocking-skip
-//go:noescape
-func wasmimport_InputStreamBlockingSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
-// Read represents the imported method "read".
-//
-// Perform a non-blocking read from the stream.
-//
-// When the source of a `read` is binary data, the bytes from the source
-// are returned verbatim. When the source of a `read` is known to the
-// implementation to be text, bytes containing the UTF-8 encoding of the
-// text are returned.
-//
-// This function returns a list of bytes containing the read data,
-// when successful. The returned list will contain up to `len` bytes;
-// it may return fewer than requested, but not more. The list is
-// empty when no bytes are available for reading at this time. The
-// pollable given by `subscribe` will be ready when more bytes are
-// available.
-//
-// This function fails with a `stream-error` when the operation
-// encounters an error, giving `last-operation-failed`, or when the
-// stream is closed, giving `closed`.
-//
-// When the caller gives a `len` of 0, it represents a request to
-// read 0 bytes. If the stream is still open, this call should
-// succeed and return an empty list, or otherwise fail with `closed`.
-//
-// The `len` parameter is a `u64`, which could represent a list of u8 which
-// is not possible to allocate in wasm32, or not desirable to allocate as
-// as a return value by the callee. The callee may return a list of bytes
-// less than `len` in size while more bytes are available for reading.
-//
-//	read: func(len: u64) -> result<list<u8>, stream-error>
-//
-//go:nosplit
-func (self InputStream) Read(len_ uint64) (result cm.Result[cm.List[uint8], cm.List[uint8], StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_InputStreamRead((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.read
-//go:noescape
-func wasmimport_InputStreamRead(self0 uint32, len0 uint64, result *cm.Result[cm.List[uint8], cm.List[uint8], StreamError])
-
-// Skip represents the imported method "skip".
-//
-// Skip bytes from a stream. Returns number of bytes skipped.
-//
-// Behaves identical to `read`, except instead of returning a list
-// of bytes, returns the number of bytes consumed from the stream.
-//
-//	skip: func(len: u64) -> result<u64, stream-error>
-//
-//go:nosplit
-func (self InputStream) Skip(len_ uint64) (result cm.Result[uint64, uint64, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_InputStreamSkip((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.skip
-//go:noescape
-func wasmimport_InputStreamSkip(self0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once either the specified stream
-// has bytes available to read or the other end of the stream has been
-// closed.
-// The created `pollable` is a child resource of the `input-stream`.
-// Implementations may trap if the `input-stream` is dropped before
-// all derived `pollable`s created with this function are dropped.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self InputStream) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_InputStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]input-stream.subscribe
-//go:noescape
-func wasmimport_InputStreamSubscribe(self0 uint32) (result0 uint32)
-
-// OutputStream represents the imported resource "wasi:io/streams@0.2.0#output-stream".
-//
-// An output bytestream.
-//
-// `output-stream`s are *non-blocking* to the extent practical on
-// underlying platforms. Except where specified otherwise, I/O operations also
-// always return promptly, after the number of bytes that can be written
-// promptly, which could even be zero. To wait for the stream to be ready to
-// accept data, the `subscribe` function to obtain a `pollable` which can be
-// polled for using `wasi:io/poll`.
-//
-//	resource output-stream
-type OutputStream cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "output-stream".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self OutputStream) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutputStreamResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [resource-drop]output-stream
-//go:noescape
-func wasmimport_OutputStreamResourceDrop(self0 uint32)
-
-// BlockingFlush represents the imported method "blocking-flush".
-//
-// Request to flush buffered output, and block until flush completes
-// and stream is ready for writing again.
-//
-//	blocking-flush: func() -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) BlockingFlush() (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutputStreamBlockingFlush((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
-// BlockingSplice represents the imported method "blocking-splice".
-//
-// Read from one stream and write to another, with blocking.
-//
-// This is similar to `splice`, except that it blocks until the
-// `output-stream` is ready for writing, and the `input-stream`
-// is ready for reading, before performing the `splice`.
-//
-//	blocking-splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
-//
-//go:nosplit
-func (self OutputStream) BlockingSplice(src InputStream, len_ uint64) (result cm.Result[uint64, uint64, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	src0 := cm.Reinterpret[uint32](src)
-	len0 := (uint64)(len_)
-	wasmimport_OutputStreamBlockingSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-splice
-//go:noescape
-func wasmimport_OutputStreamBlockingSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
-// BlockingWriteAndFlush represents the imported method "blocking-write-and-flush".
-//
-// Perform a write of up to 4096 bytes, and then flush the stream. Block
-// until all of these operations are complete, or an error occurs.
-//
-// This is a convenience wrapper around the use of `check-write`,
-// `subscribe`, `write`, and `flush`, and is implemented with the
-// following pseudo-code:
-//
-//	let pollable = this.subscribe();
-//	while !contents.is_empty() {
-//	// Wait for the stream to become writable
-//	pollable.block();
-//	let Ok(n) = this.check-write(); // eliding error handling
-//	let len = min(n, contents.len());
-//	let (chunk, rest) = contents.split_at(len);
-//	this.write(chunk  );            // eliding error handling
-//	contents = rest;
-//	}
-//	this.flush();
-//	// Wait for completion of `flush`
-//	pollable.block();
-//	// Check for any errors that arose during `flush`
-//	let _ = this.check-write();         // eliding error handling
-//
-//	blocking-write-and-flush: func(contents: list<u8>) -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) BlockingWriteAndFlush(contents cm.List[uint8]) (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	contents0, contents1 := cm.LowerList(contents)
-	wasmimport_OutputStreamBlockingWriteAndFlush((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-and-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingWriteAndFlush(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
-// BlockingWriteZeroesAndFlush represents the imported method "blocking-write-zeroes-and-flush".
-//
-// Perform a write of up to 4096 zeroes, and then flush the stream.
-// Block until all of these operations are complete, or an error
-// occurs.
-//
-// This is a convenience wrapper around the use of `check-write`,
-// `subscribe`, `write-zeroes`, and `flush`, and is implemented with
-// the following pseudo-code:
-//
-//	let pollable = this.subscribe();
-//	while num_zeroes != 0 {
-//	// Wait for the stream to become writable
-//	pollable.block();
-//	let Ok(n) = this.check-write(); // eliding error handling
-//	let len = min(n, num_zeroes);
-//	this.write-zeroes(len);         // eliding error handling
-//	num_zeroes -= len;
-//	}
-//	this.flush();
-//	// Wait for completion of `flush`
-//	pollable.block();
-//	// Check for any errors that arose during `flush`
-//	let _ = this.check-write();         // eliding error handling
-//
-//	blocking-write-zeroes-and-flush: func(len: u64) -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) BlockingWriteZeroesAndFlush(len_ uint64) (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_OutputStreamBlockingWriteZeroesAndFlush((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.blocking-write-zeroes-and-flush
-//go:noescape
-func wasmimport_OutputStreamBlockingWriteZeroesAndFlush(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])
-
-// CheckWrite represents the imported method "check-write".
-//
-// Check readiness for writing. This function never blocks.
-//
-// Returns the number of bytes permitted for the next call to `write`,
-// or an error. Calling `write` with more bytes than this function has
-// permitted will trap.
-//
-// When this function returns 0 bytes, the `subscribe` pollable will
-// become ready when this function will report at least 1 byte, or an
-// error.
-//
-//	check-write: func() -> result<u64, stream-error>
-//
-//go:nosplit
-func (self OutputStream) CheckWrite() (result cm.Result[uint64, uint64, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutputStreamCheckWrite((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.check-write
-//go:noescape
-func wasmimport_OutputStreamCheckWrite(self0 uint32, result *cm.Result[uint64, uint64, StreamError])
-
-// Flush represents the imported method "flush".
-//
-// Request to flush buffered output. This function never blocks.
-//
-// This tells the output-stream that the caller intends any buffered
-// output to be flushed. the output which is expected to be flushed
-// is all that has been passed to `write` prior to this call.
-//
-// Upon calling this function, the `output-stream` will not accept any
-// writes (`check-write` will return `ok(0)`) until the flush has
-// completed. The `subscribe` pollable will become ready when the
-// flush has completed and the stream can accept more writes.
-//
-//	flush: func() -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) Flush() (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutputStreamFlush((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.flush
-//go:noescape
-func wasmimport_OutputStreamFlush(self0 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
-// Splice represents the imported method "splice".
-//
-// Read from one stream and write to another.
-//
-// The behavior of splice is equivelant to:
-// 1. calling `check-write` on the `output-stream`
-// 2. calling `read` on the `input-stream` with the smaller of the
-// `check-write` permitted length and the `len` provided to `splice`
-// 3. calling `write` on the `output-stream` with that read data.
-//
-// Any error reported by the call to `check-write`, `read`, or
-// `write` ends the splice and reports that error.
-//
-// This function returns the number of bytes transferred; it may be less
-// than `len`.
-//
-//	splice: func(src: borrow<input-stream>, len: u64) -> result<u64, stream-error>
-//
-//go:nosplit
-func (self OutputStream) Splice(src InputStream, len_ uint64) (result cm.Result[uint64, uint64, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	src0 := cm.Reinterpret[uint32](src)
-	len0 := (uint64)(len_)
-	wasmimport_OutputStreamSplice((uint32)(self0), (uint32)(src0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.splice
-//go:noescape
-func wasmimport_OutputStreamSplice(self0 uint32, src0 uint32, len0 uint64, result *cm.Result[uint64, uint64, StreamError])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once the output-stream
-// is ready for more writing, or an error has occured. When this
-// pollable is ready, `check-write` will return `ok(n)` with n>0, or an
-// error.
-//
-// If the stream is closed, this pollable is always ready immediately.
-//
-// The created `pollable` is a child resource of the `output-stream`.
-// Implementations may trap if the `output-stream` is dropped before
-// all derived `pollable`s created with this function are dropped.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self OutputStream) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_OutputStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.subscribe
-//go:noescape
-func wasmimport_OutputStreamSubscribe(self0 uint32) (result0 uint32)
-
-// Write represents the imported method "write".
-//
-// Perform a write. This function never blocks.
-//
-// When the destination of a `write` is binary data, the bytes from
-// `contents` are written verbatim. When the destination of a `write` is
-// known to the implementation to be text, the bytes of `contents` are
-// transcoded from UTF-8 into the encoding of the destination and then
-// written.
-//
-// Precondition: check-write gave permit of Ok(n) and contents has a
-// length of less than or equal to n. Otherwise, this function will trap.
-//
-// returns Err(closed) without writing if the stream has closed since
-// the last call to check-write provided a permit.
-//
-//	write: func(contents: list<u8>) -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) Write(contents cm.List[uint8]) (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	contents0, contents1 := cm.LowerList(contents)
-	wasmimport_OutputStreamWrite((uint32)(self0), (*uint8)(contents0), (uint32)(contents1), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write
-//go:noescape
-func wasmimport_OutputStreamWrite(self0 uint32, contents0 *uint8, contents1 uint32, result *cm.Result[StreamError, struct{}, StreamError])
-
-// WriteZeroes represents the imported method "write-zeroes".
-//
-// Write zeroes to a stream.
-//
-// This should be used precisely like `write` with the exact same
-// preconditions (must use check-write first), but instead of
-// passing a list of bytes, you simply pass the number of zero-bytes
-// that should be written.
-//
-//	write-zeroes: func(len: u64) -> result<_, stream-error>
-//
-//go:nosplit
-func (self OutputStream) WriteZeroes(len_ uint64) (result cm.Result[StreamError, struct{}, StreamError]) {
-	self0 := cm.Reinterpret[uint32](self)
-	len0 := (uint64)(len_)
-	wasmimport_OutputStreamWriteZeroes((uint32)(self0), (uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:io/streams@0.2.0 [method]output-stream.write-zeroes
-//go:noescape
-func wasmimport_OutputStreamWriteZeroes(self0 uint32, len0 uint64, result *cm.Result[StreamError, struct{}, StreamError])

src/internal/wasi/random/v0.2.0/insecure-seed/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/insecure-seed/insecure-seed.wit.go

@@ -1,43 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package insecureseed represents the imported interface "wasi:random/insecure-seed@0.2.0".
-//
-// The insecure-seed interface for seeding hash-map DoS resistance.
-//
-// It is intended to be portable at least between Unix-family platforms and
-// Windows.
-package insecureseed
-
-// InsecureSeed represents the imported function "insecure-seed".
-//
-// Return a 128-bit value that may contain a pseudo-random value.
-//
-// The returned value is not required to be computed from a CSPRNG, and may
-// even be entirely deterministic. Host implementations are encouraged to
-// provide pseudo-random values to any program exposed to
-// attacker-controlled content, to enable DoS protection built into many
-// languages' hash-map implementations.
-//
-// This function is intended to only be called once, by a source language
-// to initialize Denial Of Service (DoS) protection in its hash-map
-// implementation.
-//
-// # Expected future evolution
-//
-// This will likely be changed to a value import, to prevent it from being
-// called multiple times and potentially used for purposes other than DoS
-// protection.
-//
-//	insecure-seed: func() -> tuple<u64, u64>
-//
-//go:nosplit
-func InsecureSeed() (result [2]uint64) {
-	wasmimport_InsecureSeed(&result)
-	return
-}
-
-//go:wasmimport wasi:random/insecure-seed@0.2.0 insecure-seed
-//go:noescape
-func wasmimport_InsecureSeed(result *[2]uint64)

src/internal/wasi/random/v0.2.0/insecure/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/insecure/insecure.wit.go

@@ -1,59 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package insecure represents the imported interface "wasi:random/insecure@0.2.0".
-//
-// The insecure interface for insecure pseudo-random numbers.
-//
-// It is intended to be portable at least between Unix-family platforms and
-// Windows.
-package insecure
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// GetInsecureRandomBytes represents the imported function "get-insecure-random-bytes".
-//
-// Return `len` insecure pseudo-random bytes.
-//
-// This function is not cryptographically secure. Do not use it for
-// anything related to security.
-//
-// There are no requirements on the values of the returned bytes, however
-// implementations are encouraged to return evenly distributed values with
-// a long period.
-//
-//	get-insecure-random-bytes: func(len: u64) -> list<u8>
-//
-//go:nosplit
-func GetInsecureRandomBytes(len_ uint64) (result cm.List[uint8]) {
-	len0 := (uint64)(len_)
-	wasmimport_GetInsecureRandomBytes((uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-bytes
-//go:noescape
-func wasmimport_GetInsecureRandomBytes(len0 uint64, result *cm.List[uint8])
-
-// GetInsecureRandomU64 represents the imported function "get-insecure-random-u64".
-//
-// Return an insecure pseudo-random `u64` value.
-//
-// This function returns the same type of pseudo-random data as
-// `get-insecure-random-bytes`, represented as a `u64`.
-//
-//	get-insecure-random-u64: func() -> u64
-//
-//go:nosplit
-func GetInsecureRandomU64() (result uint64) {
-	result0 := wasmimport_GetInsecureRandomU64()
-	result = (uint64)((uint64)(result0))
-	return
-}
-
-//go:wasmimport wasi:random/insecure@0.2.0 get-insecure-random-u64
-//go:noescape
-func wasmimport_GetInsecureRandomU64() (result0 uint64)

src/internal/wasi/random/v0.2.0/random/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/random/v0.2.0/random/random.wit.go

@@ -1,63 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package random represents the imported interface "wasi:random/random@0.2.0".
-//
-// WASI Random is a random data API.
-//
-// It is intended to be portable at least between Unix-family platforms and
-// Windows.
-package random
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// GetRandomBytes represents the imported function "get-random-bytes".
-//
-// Return `len` cryptographically-secure random or pseudo-random bytes.
-//
-// This function must produce data at least as cryptographically secure and
-// fast as an adequately seeded cryptographically-secure pseudo-random
-// number generator (CSPRNG). It must not block, from the perspective of
-// the calling program, under any circumstances, including on the first
-// request and on requests for numbers of bytes. The returned data must
-// always be unpredictable.
-//
-// This function must always return fresh data. Deterministic environments
-// must omit this function, rather than implementing it with deterministic
-// data.
-//
-//	get-random-bytes: func(len: u64) -> list<u8>
-//
-//go:nosplit
-func GetRandomBytes(len_ uint64) (result cm.List[uint8]) {
-	len0 := (uint64)(len_)
-	wasmimport_GetRandomBytes((uint64)(len0), &result)
-	return
-}
-
-//go:wasmimport wasi:random/random@0.2.0 get-random-bytes
-//go:noescape
-func wasmimport_GetRandomBytes(len0 uint64, result *cm.List[uint8])
-
-// GetRandomU64 represents the imported function "get-random-u64".
-//
-// Return a cryptographically-secure random or pseudo-random `u64` value.
-//
-// This function returns the same type of data as `get-random-bytes`,
-// represented as a `u64`.
-//
-//	get-random-u64: func() -> u64
-//
-//go:nosplit
-func GetRandomU64() (result uint64) {
-	result0 := wasmimport_GetRandomU64()
-	result = (uint64)((uint64)(result0))
-	return
-}
-
-//go:wasmimport wasi:random/random@0.2.0 get-random-u64
-//go:noescape
-func wasmimport_GetRandomU64() (result0 uint64)

src/internal/wasi/sockets/v0.2.0/instance-network/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/instance-network/instance-network.wit.go

@@ -1,30 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package instancenetwork represents the imported interface "wasi:sockets/instance-network@0.2.0".
-//
-// This interface provides a value-export of the default network handle..
-package instancenetwork
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/sockets/v0.2.0/network"
-)
-
-// InstanceNetwork represents the imported function "instance-network".
-//
-// Get a handle to the default network.
-//
-//	instance-network: func() -> network
-//
-//go:nosplit
-func InstanceNetwork() (result network.Network) {
-	result0 := wasmimport_InstanceNetwork()
-	result = cm.Reinterpret[network.Network]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/instance-network@0.2.0 instance-network
-//go:noescape
-func wasmimport_InstanceNetwork() (result0 uint32)

src/internal/wasi/sockets/v0.2.0/ip-name-lookup/abi.go

@@ -1,16 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package ipnamelookup
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/sockets/v0.2.0/network"
-	"unsafe"
-)
-
-// OptionIPAddressShape is used for storage in variant or result types.
-type OptionIPAddressShape struct {
-	shape [unsafe.Sizeof(cm.Option[network.IPAddress]{})]byte
-}

src/internal/wasi/sockets/v0.2.0/ip-name-lookup/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/ip-name-lookup/ip-name-lookup.wit.go

@@ -1,123 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package ipnamelookup represents the imported interface "wasi:sockets/ip-name-lookup@0.2.0".
-package ipnamelookup
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/poll"
-	"internal/wasi/sockets/v0.2.0/network"
-)
-
-// ResolveAddressStream represents the imported resource "wasi:sockets/ip-name-lookup@0.2.0#resolve-address-stream".
-//
-//	resource resolve-address-stream
-type ResolveAddressStream cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "resolve-address-stream".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self ResolveAddressStream) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_ResolveAddressStreamResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [resource-drop]resolve-address-stream
-//go:noescape
-func wasmimport_ResolveAddressStreamResourceDrop(self0 uint32)
-
-// ResolveNextAddress represents the imported method "resolve-next-address".
-//
-// Returns the next address from the resolver.
-//
-// This function should be called multiple times. On each call, it will
-// return the next address in connection order preference. If all
-// addresses have been exhausted, this function returns `none`.
-//
-// This function never returns IPv4-mapped IPv6 addresses.
-//
-// # Typical errors
-// - `name-unresolvable`:          Name does not exist or has no suitable associated
-// IP addresses. (EAI_NONAME, EAI_NODATA, EAI_ADDRFAMILY)
-// - `temporary-resolver-failure`: A temporary failure in name resolution occurred.
-// (EAI_AGAIN)
-// - `permanent-resolver-failure`: A permanent failure in name resolution occurred.
-// (EAI_FAIL)
-// - `would-block`:                A result is not available yet. (EWOULDBLOCK, EAGAIN)
-//
-//	resolve-next-address: func() -> result<option<ip-address>, error-code>
-//
-//go:nosplit
-func (self ResolveAddressStream) ResolveNextAddress() (result cm.Result[OptionIPAddressShape, cm.Option[network.IPAddress], network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_ResolveAddressStreamResolveNextAddress((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.resolve-next-address
-//go:noescape
-func wasmimport_ResolveAddressStreamResolveNextAddress(self0 uint32, result *cm.Result[OptionIPAddressShape, cm.Option[network.IPAddress], network.ErrorCode])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once the stream is ready for I/O.
-//
-// Note: this function is here for WASI Preview2 only.
-// It's planned to be removed when `future` is natively supported in Preview3.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self ResolveAddressStream) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_ResolveAddressStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 [method]resolve-address-stream.subscribe
-//go:noescape
-func wasmimport_ResolveAddressStreamSubscribe(self0 uint32) (result0 uint32)
-
-// ResolveAddresses represents the imported function "resolve-addresses".
-//
-// Resolve an internet host name to a list of IP addresses.
-//
-// Unicode domain names are automatically converted to ASCII using IDNA encoding.
-// If the input is an IP address string, the address is parsed and returned
-// as-is without making any external requests.
-//
-// See the wasi-socket proposal README.md for a comparison with getaddrinfo.
-//
-// This function never blocks. It either immediately fails or immediately
-// returns successfully with a `resolve-address-stream` that can be used
-// to (asynchronously) fetch the results.
-//
-// # Typical errors
-// - `invalid-argument`: `name` is a syntactically invalid domain name or IP address.
-//
-// # References:
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getaddrinfo.html>
-// - <https://man7.org/linux/man-pages/man3/getaddrinfo.3.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/ws2tcpip/nf-ws2tcpip-getaddrinfo>
-// - <https://man.freebsd.org/cgi/man.cgi?query=getaddrinfo&sektion=3>
-//
-//	resolve-addresses: func(network: borrow<network>, name: string) -> result<resolve-address-stream,
-//	error-code>
-//
-//go:nosplit
-func ResolveAddresses(network_ network.Network, name string) (result cm.Result[ResolveAddressStream, ResolveAddressStream, network.ErrorCode]) {
-	network0 := cm.Reinterpret[uint32](network_)
-	name0, name1 := cm.LowerString(name)
-	wasmimport_ResolveAddresses((uint32)(network0), (*uint8)(name0), (uint32)(name1), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/ip-name-lookup@0.2.0 resolve-addresses
-//go:noescape
-func wasmimport_ResolveAddresses(network0 uint32, name0 *uint8, name1 uint32, result *cm.Result[ResolveAddressStream, ResolveAddressStream, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/network/abi.go

@@ -1,14 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package network
-
-import (
-	"unsafe"
-)
-
-// IPv6SocketAddressShape is used for storage in variant or result types.
-type IPv6SocketAddressShape struct {
-	shape [unsafe.Sizeof(IPv6SocketAddress{})]byte
-}

src/internal/wasi/sockets/v0.2.0/network/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/network/network.wit.go

@@ -1,317 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package network represents the imported interface "wasi:sockets/network@0.2.0".
-package network
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-)
-
-// Network represents the imported resource "wasi:sockets/network@0.2.0#network".
-//
-// An opaque resource that represents access to (a subset of) the network.
-// This enables context-based security for networking.
-// There is no need for this to map 1:1 to a physical network interface.
-//
-//	resource network
-type Network cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "network".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self Network) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_NetworkResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/network@0.2.0 [resource-drop]network
-//go:noescape
-func wasmimport_NetworkResourceDrop(self0 uint32)
-
-// ErrorCode represents the enum "wasi:sockets/network@0.2.0#error-code".
-//
-// Error codes.
-//
-// In theory, every API can return any error code.
-// In practice, API's typically only return the errors documented per API
-// combined with a couple of errors that are always possible:
-// - `unknown`
-// - `access-denied`
-// - `not-supported`
-// - `out-of-memory`
-// - `concurrency-conflict`
-//
-// See each individual API for what the POSIX equivalents are. They sometimes differ
-// per API.
-//
-//	enum error-code {
-//		unknown,
-//		access-denied,
-//		not-supported,
-//		invalid-argument,
-//		out-of-memory,
-//		timeout,
-//		concurrency-conflict,
-//		not-in-progress,
-//		would-block,
-//		invalid-state,
-//		new-socket-limit,
-//		address-not-bindable,
-//		address-in-use,
-//		remote-unreachable,
-//		connection-refused,
-//		connection-reset,
-//		connection-aborted,
-//		datagram-too-large,
-//		name-unresolvable,
-//		temporary-resolver-failure,
-//		permanent-resolver-failure
-//	}
-type ErrorCode uint8
-
-const (
-	// Unknown error
-	ErrorCodeUnknown ErrorCode = iota
-
-	// Access denied.
-	//
-	// POSIX equivalent: EACCES, EPERM
-	ErrorCodeAccessDenied
-
-	// The operation is not supported.
-	//
-	// POSIX equivalent: EOPNOTSUPP
-	ErrorCodeNotSupported
-
-	// One of the arguments is invalid.
-	//
-	// POSIX equivalent: EINVAL
-	ErrorCodeInvalidArgument
-
-	// Not enough memory to complete the operation.
-	//
-	// POSIX equivalent: ENOMEM, ENOBUFS, EAI_MEMORY
-	ErrorCodeOutOfMemory
-
-	// The operation timed out before it could finish completely.
-	ErrorCodeTimeout
-
-	// This operation is incompatible with another asynchronous operation that is already
-	// in progress.
-	//
-	// POSIX equivalent: EALREADY
-	ErrorCodeConcurrencyConflict
-
-	// Trying to finish an asynchronous operation that:
-	// - has not been started yet, or:
-	// - was already finished by a previous `finish-*` call.
-	//
-	// Note: this is scheduled to be removed when `future`s are natively supported.
-	ErrorCodeNotInProgress
-
-	// The operation has been aborted because it could not be completed immediately.
-	//
-	// Note: this is scheduled to be removed when `future`s are natively supported.
-	ErrorCodeWouldBlock
-
-	// The operation is not valid in the socket's current state.
-	ErrorCodeInvalidState
-
-	// A new socket resource could not be created because of a system limit.
-	ErrorCodeNewSocketLimit
-
-	// A bind operation failed because the provided address is not an address that the
-	// `network` can bind to.
-	ErrorCodeAddressNotBindable
-
-	// A bind operation failed because the provided address is already in use or because
-	// there are no ephemeral ports available.
-	ErrorCodeAddressInUse
-
-	// The remote address is not reachable
-	ErrorCodeRemoteUnreachable
-
-	// The TCP connection was forcefully rejected
-	ErrorCodeConnectionRefused
-
-	// The TCP connection was reset.
-	ErrorCodeConnectionReset
-
-	// A TCP connection was aborted.
-	ErrorCodeConnectionAborted
-
-	// The size of a datagram sent to a UDP socket exceeded the maximum
-	// supported size.
-	ErrorCodeDatagramTooLarge
-
-	// Name does not exist or has no suitable associated IP addresses.
-	ErrorCodeNameUnresolvable
-
-	// A temporary failure in name resolution occurred.
-	ErrorCodeTemporaryResolverFailure
-
-	// A permanent failure in name resolution occurred.
-	ErrorCodePermanentResolverFailure
-)
-
-var stringsErrorCode = [21]string{
-	"unknown",
-	"access-denied",
-	"not-supported",
-	"invalid-argument",
-	"out-of-memory",
-	"timeout",
-	"concurrency-conflict",
-	"not-in-progress",
-	"would-block",
-	"invalid-state",
-	"new-socket-limit",
-	"address-not-bindable",
-	"address-in-use",
-	"remote-unreachable",
-	"connection-refused",
-	"connection-reset",
-	"connection-aborted",
-	"datagram-too-large",
-	"name-unresolvable",
-	"temporary-resolver-failure",
-	"permanent-resolver-failure",
-}
-
-// String implements [fmt.Stringer], returning the enum case name of e.
-func (e ErrorCode) String() string {
-	return stringsErrorCode[e]
-}
-
-// IPAddressFamily represents the enum "wasi:sockets/network@0.2.0#ip-address-family".
-//
-//	enum ip-address-family {
-//		ipv4,
-//		ipv6
-//	}
-type IPAddressFamily uint8
-
-const (
-	// Similar to `AF_INET` in POSIX.
-	IPAddressFamilyIPv4 IPAddressFamily = iota
-
-	// Similar to `AF_INET6` in POSIX.
-	IPAddressFamilyIPv6
-)
-
-var stringsIPAddressFamily = [2]string{
-	"ipv4",
-	"ipv6",
-}
-
-// String implements [fmt.Stringer], returning the enum case name of e.
-func (e IPAddressFamily) String() string {
-	return stringsIPAddressFamily[e]
-}
-
-// IPv4Address represents the tuple "wasi:sockets/network@0.2.0#ipv4-address".
-//
-//	type ipv4-address = tuple<u8, u8, u8, u8>
-type IPv4Address [4]uint8
-
-// IPv6Address represents the tuple "wasi:sockets/network@0.2.0#ipv6-address".
-//
-//	type ipv6-address = tuple<u16, u16, u16, u16, u16, u16, u16, u16>
-type IPv6Address [8]uint16
-
-// IPAddress represents the variant "wasi:sockets/network@0.2.0#ip-address".
-//
-//	variant ip-address {
-//		ipv4(ipv4-address),
-//		ipv6(ipv6-address),
-//	}
-type IPAddress cm.Variant[uint8, IPv6Address, IPv6Address]
-
-// IPAddressIPv4 returns a [IPAddress] of case "ipv4".
-func IPAddressIPv4(data IPv4Address) IPAddress {
-	return cm.New[IPAddress](0, data)
-}
-
-// IPv4 returns a non-nil *[IPv4Address] if [IPAddress] represents the variant case "ipv4".
-func (self *IPAddress) IPv4() *IPv4Address {
-	return cm.Case[IPv4Address](self, 0)
-}
-
-// IPAddressIPv6 returns a [IPAddress] of case "ipv6".
-func IPAddressIPv6(data IPv6Address) IPAddress {
-	return cm.New[IPAddress](1, data)
-}
-
-// IPv6 returns a non-nil *[IPv6Address] if [IPAddress] represents the variant case "ipv6".
-func (self *IPAddress) IPv6() *IPv6Address {
-	return cm.Case[IPv6Address](self, 1)
-}
-
-// IPv4SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv4-socket-address".
-//
-//	record ipv4-socket-address {
-//		port: u16,
-//		address: ipv4-address,
-//	}
-type IPv4SocketAddress struct {
-	// sin_port
-	Port uint16
-
-	// sin_addr
-	Address IPv4Address
-}
-
-// IPv6SocketAddress represents the record "wasi:sockets/network@0.2.0#ipv6-socket-address".
-//
-//	record ipv6-socket-address {
-//		port: u16,
-//		flow-info: u32,
-//		address: ipv6-address,
-//		scope-id: u32,
-//	}
-type IPv6SocketAddress struct {
-	// sin6_port
-	Port uint16
-
-	// sin6_flowinfo
-	FlowInfo uint32
-
-	// sin6_addr
-	Address IPv6Address
-
-	// sin6_scope_id
-	ScopeID uint32
-}
-
-// IPSocketAddress represents the variant "wasi:sockets/network@0.2.0#ip-socket-address".
-//
-//	variant ip-socket-address {
-//		ipv4(ipv4-socket-address),
-//		ipv6(ipv6-socket-address),
-//	}
-type IPSocketAddress cm.Variant[uint8, IPv6SocketAddressShape, IPv6SocketAddress]
-
-// IPSocketAddressIPv4 returns a [IPSocketAddress] of case "ipv4".
-func IPSocketAddressIPv4(data IPv4SocketAddress) IPSocketAddress {
-	return cm.New[IPSocketAddress](0, data)
-}
-
-// IPv4 returns a non-nil *[IPv4SocketAddress] if [IPSocketAddress] represents the variant case "ipv4".
-func (self *IPSocketAddress) IPv4() *IPv4SocketAddress {
-	return cm.Case[IPv4SocketAddress](self, 0)
-}
-
-// IPSocketAddressIPv6 returns a [IPSocketAddress] of case "ipv6".
-func IPSocketAddressIPv6(data IPv6SocketAddress) IPSocketAddress {
-	return cm.New[IPSocketAddress](1, data)
-}
-
-// IPv6 returns a non-nil *[IPv6SocketAddress] if [IPSocketAddress] represents the variant case "ipv6".
-func (self *IPSocketAddress) IPv6() *IPv6SocketAddress {
-	return cm.Case[IPv6SocketAddress](self, 1)
-}

src/internal/wasi/sockets/v0.2.0/tcp-create-socket/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/tcp-create-socket/tcp-create-socket.wit.go

@@ -1,54 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package tcpcreatesocket represents the imported interface "wasi:sockets/tcp-create-socket@0.2.0".
-package tcpcreatesocket
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/sockets/v0.2.0/network"
-	"internal/wasi/sockets/v0.2.0/tcp"
-)
-
-// CreateTCPSocket represents the imported function "create-tcp-socket".
-//
-// Create a new TCP socket.
-//
-// Similar to `socket(AF_INET or AF_INET6, SOCK_STREAM, IPPROTO_TCP)` in POSIX.
-// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
-//
-// This function does not require a network capability handle. This is considered
-// to be safe because
-// at time of creation, the socket is not bound to any `network` yet. Up to the moment
-// `bind`/`connect`
-// is called, the socket is effectively an in-memory configuration object, unable
-// to communicate with the outside world.
-//
-// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous
-// operations.
-//
-// # Typical errors
-// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
-// - `new-socket-limit`:  The new socket resource could not be created because of
-// a system limit. (EMFILE, ENFILE)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-//
-//	create-tcp-socket: func(address-family: ip-address-family) -> result<tcp-socket,
-//	error-code>
-//
-//go:nosplit
-func CreateTCPSocket(addressFamily network.IPAddressFamily) (result cm.Result[tcp.TCPSocket, tcp.TCPSocket, network.ErrorCode]) {
-	addressFamily0 := (uint32)(addressFamily)
-	wasmimport_CreateTCPSocket((uint32)(addressFamily0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp-create-socket@0.2.0 create-tcp-socket
-//go:noescape
-func wasmimport_CreateTCPSocket(addressFamily0 uint32, result *cm.Result[tcp.TCPSocket, tcp.TCPSocket, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/tcp/abi.go

@@ -1,88 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package tcp
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/streams"
-	"internal/wasi/sockets/v0.2.0/network"
-	"unsafe"
-)
-
-// TupleTCPSocketInputStreamOutputStreamShape is used for storage in variant or result types.
-type TupleTCPSocketInputStreamOutputStreamShape struct {
-	shape [unsafe.Sizeof(cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream]{})]byte
-}
-
-// TupleInputStreamOutputStreamShape is used for storage in variant or result types.
-type TupleInputStreamOutputStreamShape struct {
-	shape [unsafe.Sizeof(cm.Tuple[streams.InputStream, streams.OutputStream]{})]byte
-}
-
-// IPSocketAddressShape is used for storage in variant or result types.
-type IPSocketAddressShape struct {
-	shape [unsafe.Sizeof(network.IPSocketAddress{})]byte
-}
-
-func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
-	f0 = (uint32)(v[0])
-	f1 = (uint32)(v[1])
-	f2 = (uint32)(v[2])
-	f3 = (uint32)(v[3])
-	return
-}
-
-func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
-	f0 = (uint32)(v.Port)
-	f1, f2, f3, f4 = lower_IPv4Address(v.Address)
-	return
-}
-
-func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
-	f0 = (uint32)(v[0])
-	f1 = (uint32)(v[1])
-	f2 = (uint32)(v[2])
-	f3 = (uint32)(v[3])
-	f4 = (uint32)(v[4])
-	f5 = (uint32)(v[5])
-	f6 = (uint32)(v[6])
-	f7 = (uint32)(v[7])
-	return
-}
-
-func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
-	f0 = (uint32)(v.Port)
-	f1 = (uint32)(v.FlowInfo)
-	f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
-	f10 = (uint32)(v.ScopeID)
-	return
-}
-
-func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
-	f0 = (uint32)(v.Tag())
-	switch f0 {
-	case 0: // ipv4
-		v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
-		f1 = (uint32)(v1)
-		f2 = (uint32)(v2)
-		f3 = (uint32)(v3)
-		f4 = (uint32)(v4)
-		f5 = (uint32)(v5)
-	case 1: // ipv6
-		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
-		f1 = (uint32)(v1)
-		f2 = (uint32)(v2)
-		f3 = (uint32)(v3)
-		f4 = (uint32)(v4)
-		f5 = (uint32)(v5)
-		f6 = (uint32)(v6)
-		f7 = (uint32)(v7)
-		f8 = (uint32)(v8)
-		f9 = (uint32)(v9)
-		f10 = (uint32)(v10)
-		f11 = (uint32)(v11)
-	}
-	return
-}

src/internal/wasi/sockets/v0.2.0/tcp/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/tcp/tcp.wit.go

@@ -1,850 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package tcp represents the imported interface "wasi:sockets/tcp@0.2.0".
-package tcp
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	monotonicclock "internal/wasi/clocks/v0.2.0/monotonic-clock"
-	"internal/wasi/io/v0.2.0/poll"
-	"internal/wasi/io/v0.2.0/streams"
-	"internal/wasi/sockets/v0.2.0/network"
-)
-
-// ShutdownType represents the enum "wasi:sockets/tcp@0.2.0#shutdown-type".
-//
-//	enum shutdown-type {
-//		receive,
-//		send,
-//		both
-//	}
-type ShutdownType uint8
-
-const (
-	// Similar to `SHUT_RD` in POSIX.
-	ShutdownTypeReceive ShutdownType = iota
-
-	// Similar to `SHUT_WR` in POSIX.
-	ShutdownTypeSend
-
-	// Similar to `SHUT_RDWR` in POSIX.
-	ShutdownTypeBoth
-)
-
-var stringsShutdownType = [3]string{
-	"receive",
-	"send",
-	"both",
-}
-
-// String implements [fmt.Stringer], returning the enum case name of e.
-func (e ShutdownType) String() string {
-	return stringsShutdownType[e]
-}
-
-// TCPSocket represents the imported resource "wasi:sockets/tcp@0.2.0#tcp-socket".
-//
-// A TCP socket resource.
-//
-// The socket can be in one of the following states:
-// - `unbound`
-// - `bind-in-progress`
-// - `bound` (See note below)
-// - `listen-in-progress`
-// - `listening`
-// - `connect-in-progress`
-// - `connected`
-// - `closed`
-// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md>
-// for a more information.
-//
-// Note: Except where explicitly mentioned, whenever this documentation uses
-// the term "bound" without backticks it actually means: in the `bound` state *or
-// higher*.
-// (i.e. `bound`, `listen-in-progress`, `listening`, `connect-in-progress` or `connected`)
-//
-// In addition to the general error codes documented on the
-// `network::error-code` type, TCP socket methods may always return
-// `error(invalid-state)` when in the `closed` state.
-//
-//	resource tcp-socket
-type TCPSocket cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "tcp-socket".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self TCPSocket) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [resource-drop]tcp-socket
-//go:noescape
-func wasmimport_TCPSocketResourceDrop(self0 uint32)
-
-// Accept represents the imported method "accept".
-//
-// Accept a new client socket.
-//
-// The returned socket is bound and in the `connected` state. The following properties
-// are inherited from the listener socket:
-// - `address-family`
-// - `keep-alive-enabled`
-// - `keep-alive-idle-time`
-// - `keep-alive-interval`
-// - `keep-alive-count`
-// - `hop-limit`
-// - `receive-buffer-size`
-// - `send-buffer-size`
-//
-// On success, this function returns the newly accepted client socket along with
-// a pair of streams that can be used to read & write to the connection.
-//
-// # Typical errors
-// - `invalid-state`:      Socket is not in the `listening` state. (EINVAL)
-// - `would-block`:        No pending connections at the moment. (EWOULDBLOCK, EAGAIN)
-// - `connection-aborted`: An incoming connection was pending, but was terminated
-// by the client before this listener could accept it. (ECONNABORTED)
-// - `new-socket-limit`:   The new socket resource could not be created because of
-// a system limit. (EMFILE, ENFILE)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/accept.html>
-// - <https://man7.org/linux/man-pages/man2/accept.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-accept>
-// - <https://man.freebsd.org/cgi/man.cgi?query=accept&sektion=2>
-//
-//	accept: func() -> result<tuple<tcp-socket, input-stream, output-stream>, error-code>
-//
-//go:nosplit
-func (self TCPSocket) Accept() (result cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketAccept((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.accept
-//go:noescape
-func wasmimport_TCPSocketAccept(self0 uint32, result *cm.Result[TupleTCPSocketInputStreamOutputStreamShape, cm.Tuple3[TCPSocket, streams.InputStream, streams.OutputStream], network.ErrorCode])
-
-// AddressFamily represents the imported method "address-family".
-//
-// Whether this is a IPv4 or IPv6 socket.
-//
-// Equivalent to the SO_DOMAIN socket option.
-//
-//	address-family: func() -> ip-address-family
-//
-//go:nosplit
-func (self TCPSocket) AddressFamily() (result network.IPAddressFamily) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_TCPSocketAddressFamily((uint32)(self0))
-	result = (network.IPAddressFamily)((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.address-family
-//go:noescape
-func wasmimport_TCPSocketAddressFamily(self0 uint32) (result0 uint32)
-
-// FinishBind represents the imported method "finish-bind".
-//
-//	finish-bind: func() -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) FinishBind() (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketFinishBind((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-bind
-//go:noescape
-func wasmimport_TCPSocketFinishBind(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// FinishConnect represents the imported method "finish-connect".
-//
-//	finish-connect: func() -> result<tuple<input-stream, output-stream>, error-code>
-//
-//go:nosplit
-func (self TCPSocket) FinishConnect() (result cm.Result[TupleInputStreamOutputStreamShape, cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketFinishConnect((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-connect
-//go:noescape
-func wasmimport_TCPSocketFinishConnect(self0 uint32, result *cm.Result[TupleInputStreamOutputStreamShape, cm.Tuple[streams.InputStream, streams.OutputStream], network.ErrorCode])
-
-// FinishListen represents the imported method "finish-listen".
-//
-//	finish-listen: func() -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) FinishListen() (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketFinishListen((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.finish-listen
-//go:noescape
-func wasmimport_TCPSocketFinishListen(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// HopLimit represents the imported method "hop-limit".
-//
-// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
-//
-//	hop-limit: func() -> result<u8, error-code>
-//
-//go:nosplit
-func (self TCPSocket) HopLimit() (result cm.Result[uint8, uint8, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketHopLimit((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.hop-limit
-//go:noescape
-func wasmimport_TCPSocketHopLimit(self0 uint32, result *cm.Result[uint8, uint8, network.ErrorCode])
-
-// IsListening represents the imported method "is-listening".
-//
-// Whether the socket is in the `listening` state.
-//
-// Equivalent to the SO_ACCEPTCONN socket option.
-//
-//	is-listening: func() -> bool
-//
-//go:nosplit
-func (self TCPSocket) IsListening() (result bool) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_TCPSocketIsListening((uint32)(self0))
-	result = cm.U32ToBool((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.is-listening
-//go:noescape
-func wasmimport_TCPSocketIsListening(self0 uint32) (result0 uint32)
-
-// KeepAliveCount represents the imported method "keep-alive-count".
-//
-// The maximum amount of keepalive packets TCP should send before aborting the connection.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-// I.e. after setting a value, reading the same setting back may return a different
-// value.
-//
-// Equivalent to the TCP_KEEPCNT socket option.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The provided value was 0.
-//
-//	keep-alive-count: func() -> result<u32, error-code>
-//
-//go:nosplit
-func (self TCPSocket) KeepAliveCount() (result cm.Result[uint32, uint32, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketKeepAliveCount((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-count
-//go:noescape
-func wasmimport_TCPSocketKeepAliveCount(self0 uint32, result *cm.Result[uint32, uint32, network.ErrorCode])
-
-// KeepAliveEnabled represents the imported method "keep-alive-enabled".
-//
-// Enables or disables keepalive.
-//
-// The keepalive behavior can be adjusted using:
-// - `keep-alive-idle-time`
-// - `keep-alive-interval`
-// - `keep-alive-count`
-// These properties can be configured while `keep-alive-enabled` is false, but only
-// come into effect when `keep-alive-enabled` is true.
-//
-// Equivalent to the SO_KEEPALIVE socket option.
-//
-//	keep-alive-enabled: func() -> result<bool, error-code>
-//
-//go:nosplit
-func (self TCPSocket) KeepAliveEnabled() (result cm.Result[bool, bool, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketKeepAliveEnabled((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-enabled
-//go:noescape
-func wasmimport_TCPSocketKeepAliveEnabled(self0 uint32, result *cm.Result[bool, bool, network.ErrorCode])
-
-// KeepAliveIdleTime represents the imported method "keep-alive-idle-time".
-//
-// Amount of time the connection has to be idle before TCP starts sending keepalive
-// packets.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-// I.e. after setting a value, reading the same setting back may return a different
-// value.
-//
-// Equivalent to the TCP_KEEPIDLE socket option. (TCP_KEEPALIVE on MacOS)
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The provided value was 0.
-//
-//	keep-alive-idle-time: func() -> result<duration, error-code>
-//
-//go:nosplit
-func (self TCPSocket) KeepAliveIdleTime() (result cm.Result[uint64, monotonicclock.Duration, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketKeepAliveIdleTime((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-idle-time
-//go:noescape
-func wasmimport_TCPSocketKeepAliveIdleTime(self0 uint32, result *cm.Result[uint64, monotonicclock.Duration, network.ErrorCode])
-
-// KeepAliveInterval represents the imported method "keep-alive-interval".
-//
-// The time between keepalive packets.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-// I.e. after setting a value, reading the same setting back may return a different
-// value.
-//
-// Equivalent to the TCP_KEEPINTVL socket option.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The provided value was 0.
-//
-//	keep-alive-interval: func() -> result<duration, error-code>
-//
-//go:nosplit
-func (self TCPSocket) KeepAliveInterval() (result cm.Result[uint64, monotonicclock.Duration, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketKeepAliveInterval((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.keep-alive-interval
-//go:noescape
-func wasmimport_TCPSocketKeepAliveInterval(self0 uint32, result *cm.Result[uint64, monotonicclock.Duration, network.ErrorCode])
-
-// LocalAddress represents the imported method "local-address".
-//
-// Get the bound local address.
-//
-// POSIX mentions:
-// > If the socket has not been bound to a local name, the value
-// > stored in the object pointed to by `address` is unspecified.
-//
-// WASI is stricter and requires `local-address` to return `invalid-state` when the
-// socket hasn't been bound yet.
-//
-// # Typical errors
-// - `invalid-state`: The socket is not bound to any local address.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-//
-//	local-address: func() -> result<ip-socket-address, error-code>
-//
-//go:nosplit
-func (self TCPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketLocalAddress((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.local-address
-//go:noescape
-func wasmimport_TCPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
-// ReceiveBufferSize represents the imported method "receive-buffer-size".
-//
-// The kernel buffer space reserved for sends/receives on this socket.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-// I.e. after setting a value, reading the same setting back may return a different
-// value.
-//
-// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The provided value was 0.
-//
-//	receive-buffer-size: func() -> result<u64, error-code>
-//
-//go:nosplit
-func (self TCPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketReceiveBufferSize((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.receive-buffer-size
-//go:noescape
-func wasmimport_TCPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// RemoteAddress represents the imported method "remote-address".
-//
-// Get the remote address.
-//
-// # Typical errors
-// - `invalid-state`: The socket is not connected to a remote address. (ENOTCONN)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-//
-//	remote-address: func() -> result<ip-socket-address, error-code>
-//
-//go:nosplit
-func (self TCPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketRemoteAddress((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.remote-address
-//go:noescape
-func wasmimport_TCPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
-// SendBufferSize represents the imported method "send-buffer-size".
-//
-//	send-buffer-size: func() -> result<u64, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SendBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketSendBufferSize((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.send-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// SetHopLimit represents the imported method "set-hop-limit".
-//
-//	set-hop-limit: func(value: u8) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetHopLimit(value uint8) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint32)(value)
-	wasmimport_TCPSocketSetHopLimit((uint32)(self0), (uint32)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-hop-limit
-//go:noescape
-func wasmimport_TCPSocketSetHopLimit(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetKeepAliveCount represents the imported method "set-keep-alive-count".
-//
-//	set-keep-alive-count: func(value: u32) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetKeepAliveCount(value uint32) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint32)(value)
-	wasmimport_TCPSocketSetKeepAliveCount((uint32)(self0), (uint32)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-count
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveCount(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetKeepAliveEnabled represents the imported method "set-keep-alive-enabled".
-//
-//	set-keep-alive-enabled: func(value: bool) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetKeepAliveEnabled(value bool) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := cm.BoolToU32(value)
-	wasmimport_TCPSocketSetKeepAliveEnabled((uint32)(self0), (uint32)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-enabled
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveEnabled(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetKeepAliveIdleTime represents the imported method "set-keep-alive-idle-time".
-//
-//	set-keep-alive-idle-time: func(value: duration) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetKeepAliveIdleTime(value monotonicclock.Duration) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_TCPSocketSetKeepAliveIdleTime((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-idle-time
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveIdleTime(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetKeepAliveInterval represents the imported method "set-keep-alive-interval".
-//
-//	set-keep-alive-interval: func(value: duration) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetKeepAliveInterval(value monotonicclock.Duration) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_TCPSocketSetKeepAliveInterval((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-keep-alive-interval
-//go:noescape
-func wasmimport_TCPSocketSetKeepAliveInterval(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetListenBacklogSize represents the imported method "set-listen-backlog-size".
-//
-// Hints the desired listen queue size. Implementations are free to ignore this.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-//
-// # Typical errors
-// - `not-supported`:        (set) The platform does not support changing the backlog
-// size after the initial listen.
-// - `invalid-argument`:     (set) The provided value was 0.
-// - `invalid-state`:        (set) The socket is in the `connect-in-progress` or `connected`
-// state.
-//
-//	set-listen-backlog-size: func(value: u64) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetListenBacklogSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_TCPSocketSetListenBacklogSize((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-listen-backlog-size
-//go:noescape
-func wasmimport_TCPSocketSetListenBacklogSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
-//
-//	set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetReceiveBufferSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_TCPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-receive-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetSendBufferSize represents the imported method "set-send-buffer-size".
-//
-//	set-send-buffer-size: func(value: u64) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) SetSendBufferSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_TCPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.set-send-buffer-size
-//go:noescape
-func wasmimport_TCPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// Shutdown represents the imported method "shutdown".
-//
-// Initiate a graceful shutdown.
-//
-// - `receive`: The socket is not expecting to receive any data from
-// the peer. The `input-stream` associated with this socket will be
-// closed. Any data still in the receive queue at time of calling
-// this method will be discarded.
-// - `send`: The socket has no more data to send to the peer. The `output-stream`
-// associated with this socket will be closed and a FIN packet will be sent.
-// - `both`: Same effect as `receive` & `send` combined.
-//
-// This function is idempotent. Shutting a down a direction more than once
-// has no effect and returns `ok`.
-//
-// The shutdown function does not close (drop) the socket.
-//
-// # Typical errors
-// - `invalid-state`: The socket is not in the `connected` state. (ENOTCONN)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/shutdown.html>
-// - <https://man7.org/linux/man-pages/man2/shutdown.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-shutdown>
-// - <https://man.freebsd.org/cgi/man.cgi?query=shutdown&sektion=2>
-//
-//	shutdown: func(shutdown-type: shutdown-type) -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) Shutdown(shutdownType ShutdownType) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	shutdownType0 := (uint32)(shutdownType)
-	wasmimport_TCPSocketShutdown((uint32)(self0), (uint32)(shutdownType0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.shutdown
-//go:noescape
-func wasmimport_TCPSocketShutdown(self0 uint32, shutdownType0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// StartBind represents the imported method "start-bind".
-//
-// Bind the socket to a specific network on the provided IP address and port.
-//
-// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the
-// implementation to decide which
-// network interface(s) to bind to.
-// If the TCP/UDP port is zero, the socket will be bound to a random free port.
-//
-// Bind can be attempted multiple times on the same socket, even with
-// different arguments on each iteration. But never concurrently and
-// only as long as the previous bind failed. Once a bind succeeds, the
-// binding can't be changed anymore.
-//
-// # Typical errors
-// - `invalid-argument`:          The `local-address` has the wrong address family.
-// (EAFNOSUPPORT, EFAULT on Windows)
-// - `invalid-argument`:          `local-address` is not a unicast address. (EINVAL)
-// - `invalid-argument`:          `local-address` is an IPv4-mapped IPv6 address.
-// (EINVAL)
-// - `invalid-state`:             The socket is already bound. (EINVAL)
-// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS
-// on Windows)
-// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-// - `address-not-bindable`:      `local-address` is not an address that the `network`
-// can bind to. (EADDRNOTAVAIL)
-// - `not-in-progress`:           A `bind` operation is not in progress.
-// - `would-block`:               Can't finish the operation, it is still in progress.
-// (EWOULDBLOCK, EAGAIN)
-//
-// # Implementors note
-// When binding to a non-zero port, this bind operation shouldn't be affected by the
-// TIME_WAIT
-// state of a recently closed socket on the same local address. In practice this means
-// that the SO_REUSEADDR
-// socket option should be set implicitly on all platforms, except on Windows where
-// this is the default behavior
-// and SO_REUSEADDR performs something different entirely.
-//
-// Unlike in POSIX, in WASI the bind operation is async. This enables
-// interactive WASI hosts to inject permission prompts. Runtimes that
-// don't want to make use of this ability can simply call the native
-// `bind` as part of either `start-bind` or `finish-bind`.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-//
-//	start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
-//	result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	network0 := cm.Reinterpret[uint32](network_)
-	localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
-	wasmimport_TCPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-bind
-//go:noescape
-func wasmimport_TCPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// StartConnect represents the imported method "start-connect".
-//
-// Connect to a remote endpoint.
-//
-// On success:
-// - the socket is transitioned into the `connection` state.
-// - a pair of streams is returned that can be used to read & write to the connection
-//
-// After a failed connection attempt, the socket will be in the `closed`
-// state and the only valid action left is to `drop` the socket. A single
-// socket can not be used to connect more than once.
-//
-// # Typical errors
-// - `invalid-argument`:          The `remote-address` has the wrong address family.
-// (EAFNOSUPPORT)
-// - `invalid-argument`:          `remote-address` is not a unicast address. (EINVAL,
-// ENETUNREACH on Linux, EAFNOSUPPORT on MacOS)
-// - `invalid-argument`:          `remote-address` is an IPv4-mapped IPv6 address.
-// (EINVAL, EADDRNOTAVAIL on Illumos)
-// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY
-// (`0.0.0.0` / `::`). (EADDRNOTAVAIL on Windows)
-// - `invalid-argument`:          The port in `remote-address` is set to 0. (EADDRNOTAVAIL
-// on Windows)
-// - `invalid-argument`:          The socket is already attached to a different network.
-// The `network` passed to `connect` must be identical to the one passed to `bind`.
-// - `invalid-state`:             The socket is already in the `connected` state.
-// (EISCONN)
-// - `invalid-state`:             The socket is already in the `listening` state.
-// (EOPNOTSUPP, EINVAL on Windows)
-// - `timeout`:                   Connection timed out. (ETIMEDOUT)
-// - `connection-refused`:        The connection was forcefully rejected. (ECONNREFUSED)
-// - `connection-reset`:          The connection was reset. (ECONNRESET)
-// - `connection-aborted`:        The connection was aborted. (ECONNABORTED)
-// - `remote-unreachable`:        The remote address is not reachable. (EHOSTUNREACH,
-// EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
-// - `address-in-use`:            Tried to perform an implicit bind, but there were
-// no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-// - `not-in-progress`:           A connect operation is not in progress.
-// - `would-block`:               Can't finish the operation, it is still in progress.
-// (EWOULDBLOCK, EAGAIN)
-//
-// # Implementors note
-// The POSIX equivalent of `start-connect` is the regular `connect` syscall.
-// Because all WASI sockets are non-blocking this is expected to return
-// EINPROGRESS, which should be translated to `ok()` in WASI.
-//
-// The POSIX equivalent of `finish-connect` is a `poll` for event `POLLOUT`
-// with a timeout of 0 on the socket descriptor. Followed by a check for
-// the `SO_ERROR` socket option, in case the poll signaled readiness.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-// - <https://man.freebsd.org/cgi/man.cgi?connect>
-//
-//	start-connect: func(network: borrow<network>, remote-address: ip-socket-address)
-//	-> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) StartConnect(network_ network.Network, remoteAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	network0 := cm.Reinterpret[uint32](network_)
-	remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11 := lower_IPSocketAddress(remoteAddress)
-	wasmimport_TCPSocketStartConnect((uint32)(self0), (uint32)(network0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-connect
-//go:noescape
-func wasmimport_TCPSocketStartConnect(self0 uint32, network0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// StartListen represents the imported method "start-listen".
-//
-// Start listening for new connections.
-//
-// Transitions the socket into the `listening` state.
-//
-// Unlike POSIX, the socket must already be explicitly bound.
-//
-// # Typical errors
-// - `invalid-state`:             The socket is not bound to any local address. (EDESTADDRREQ)
-// - `invalid-state`:             The socket is already in the `connected` state.
-// (EISCONN, EINVAL on BSD)
-// - `invalid-state`:             The socket is already in the `listening` state.
-// - `address-in-use`:            Tried to perform an implicit bind, but there were
-// no ephemeral ports available. (EADDRINUSE)
-// - `not-in-progress`:           A listen operation is not in progress.
-// - `would-block`:               Can't finish the operation, it is still in progress.
-// (EWOULDBLOCK, EAGAIN)
-//
-// # Implementors note
-// Unlike in POSIX, in WASI the listen operation is async. This enables
-// interactive WASI hosts to inject permission prompts. Runtimes that
-// don't want to make use of this ability can simply call the native
-// `listen` as part of either `start-listen` or `finish-listen`.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/listen.html>
-// - <https://man7.org/linux/man-pages/man2/listen.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-listen>
-// - <https://man.freebsd.org/cgi/man.cgi?query=listen&sektion=2>
-//
-//	start-listen: func() -> result<_, error-code>
-//
-//go:nosplit
-func (self TCPSocket) StartListen() (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_TCPSocketStartListen((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.start-listen
-//go:noescape
-func wasmimport_TCPSocketStartListen(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which can be used to poll for, or block on,
-// completion of any of the asynchronous operations of this socket.
-//
-// When `finish-bind`, `finish-listen`, `finish-connect` or `accept`
-// return `error(would-block)`, this pollable can be used to wait for
-// their success or failure, after which the method can be retried.
-//
-// The pollable is not limited to the async operation that happens to be
-// in progress at the time of calling `subscribe` (if any). Theoretically,
-// `subscribe` only has to be called once per socket and can then be
-// (re)used for the remainder of the socket's lifetime.
-//
-// See <https://github.com/WebAssembly/wasi-sockets/TcpSocketOperationalSemantics.md#Pollable-readiness>
-// for a more information.
-//
-// Note: this function is here for WASI Preview2 only.
-// It's planned to be removed when `future` is natively supported in Preview3.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self TCPSocket) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_TCPSocketSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/tcp@0.2.0 [method]tcp-socket.subscribe
-//go:noescape
-func wasmimport_TCPSocketSubscribe(self0 uint32) (result0 uint32)

src/internal/wasi/sockets/v0.2.0/udp-create-socket/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/udp-create-socket/udp-create-socket.wit.go

@@ -1,54 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package udpcreatesocket represents the imported interface "wasi:sockets/udp-create-socket@0.2.0".
-package udpcreatesocket
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/sockets/v0.2.0/network"
-	"internal/wasi/sockets/v0.2.0/udp"
-)
-
-// CreateUDPSocket represents the imported function "create-udp-socket".
-//
-// Create a new UDP socket.
-//
-// Similar to `socket(AF_INET or AF_INET6, SOCK_DGRAM, IPPROTO_UDP)` in POSIX.
-// On IPv6 sockets, IPV6_V6ONLY is enabled by default and can't be configured otherwise.
-//
-// This function does not require a network capability handle. This is considered
-// to be safe because
-// at time of creation, the socket is not bound to any `network` yet. Up to the moment
-// `bind` is called,
-// the socket is effectively an in-memory configuration object, unable to communicate
-// with the outside world.
-//
-// All sockets are non-blocking. Use the wasi-poll interface to block on asynchronous
-// operations.
-//
-// # Typical errors
-// - `not-supported`:     The specified `address-family` is not supported. (EAFNOSUPPORT)
-// - `new-socket-limit`:  The new socket resource could not be created because of
-// a system limit. (EMFILE, ENFILE)
-//
-// # References:
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/socket.html>
-// - <https://man7.org/linux/man-pages/man2/socket.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasocketw>
-// - <https://man.freebsd.org/cgi/man.cgi?query=socket&sektion=2>
-//
-//	create-udp-socket: func(address-family: ip-address-family) -> result<udp-socket,
-//	error-code>
-//
-//go:nosplit
-func CreateUDPSocket(addressFamily network.IPAddressFamily) (result cm.Result[udp.UDPSocket, udp.UDPSocket, network.ErrorCode]) {
-	addressFamily0 := (uint32)(addressFamily)
-	wasmimport_CreateUDPSocket((uint32)(addressFamily0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp-create-socket@0.2.0 create-udp-socket
-//go:noescape
-func wasmimport_CreateUDPSocket(addressFamily0 uint32, result *cm.Result[udp.UDPSocket, udp.UDPSocket, network.ErrorCode])

src/internal/wasi/sockets/v0.2.0/udp/abi.go

@@ -1,103 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-package udp
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/sockets/v0.2.0/network"
-	"unsafe"
-)
-
-// IPSocketAddressShape is used for storage in variant or result types.
-type IPSocketAddressShape struct {
-	shape [unsafe.Sizeof(network.IPSocketAddress{})]byte
-}
-
-func lower_IPv4Address(v network.IPv4Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32) {
-	f0 = (uint32)(v[0])
-	f1 = (uint32)(v[1])
-	f2 = (uint32)(v[2])
-	f3 = (uint32)(v[3])
-	return
-}
-
-func lower_IPv4SocketAddress(v network.IPv4SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32) {
-	f0 = (uint32)(v.Port)
-	f1, f2, f3, f4 = lower_IPv4Address(v.Address)
-	return
-}
-
-func lower_IPv6Address(v network.IPv6Address) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32) {
-	f0 = (uint32)(v[0])
-	f1 = (uint32)(v[1])
-	f2 = (uint32)(v[2])
-	f3 = (uint32)(v[3])
-	f4 = (uint32)(v[4])
-	f5 = (uint32)(v[5])
-	f6 = (uint32)(v[6])
-	f7 = (uint32)(v[7])
-	return
-}
-
-func lower_IPv6SocketAddress(v network.IPv6SocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32) {
-	f0 = (uint32)(v.Port)
-	f1 = (uint32)(v.FlowInfo)
-	f2, f3, f4, f5, f6, f7, f8, f9 = lower_IPv6Address(v.Address)
-	f10 = (uint32)(v.ScopeID)
-	return
-}
-
-func lower_IPSocketAddress(v network.IPSocketAddress) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32) {
-	f0 = (uint32)(v.Tag())
-	switch f0 {
-	case 0: // ipv4
-		v1, v2, v3, v4, v5 := lower_IPv4SocketAddress(*v.IPv4())
-		f1 = (uint32)(v1)
-		f2 = (uint32)(v2)
-		f3 = (uint32)(v3)
-		f4 = (uint32)(v4)
-		f5 = (uint32)(v5)
-	case 1: // ipv6
-		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11 := lower_IPv6SocketAddress(*v.IPv6())
-		f1 = (uint32)(v1)
-		f2 = (uint32)(v2)
-		f3 = (uint32)(v3)
-		f4 = (uint32)(v4)
-		f5 = (uint32)(v5)
-		f6 = (uint32)(v6)
-		f7 = (uint32)(v7)
-		f8 = (uint32)(v8)
-		f9 = (uint32)(v9)
-		f10 = (uint32)(v10)
-		f11 = (uint32)(v11)
-	}
-	return
-}
-
-// TupleIncomingDatagramStreamOutgoingDatagramStreamShape is used for storage in variant or result types.
-type TupleIncomingDatagramStreamOutgoingDatagramStreamShape struct {
-	shape [unsafe.Sizeof(cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream]{})]byte
-}
-
-func lower_OptionIPSocketAddress(v cm.Option[network.IPSocketAddress]) (f0 uint32, f1 uint32, f2 uint32, f3 uint32, f4 uint32, f5 uint32, f6 uint32, f7 uint32, f8 uint32, f9 uint32, f10 uint32, f11 uint32, f12 uint32) {
-	some := v.Some()
-	if some != nil {
-		f0 = 1
-		v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12 := lower_IPSocketAddress(*some)
-		f1 = (uint32)(v1)
-		f2 = (uint32)(v2)
-		f3 = (uint32)(v3)
-		f4 = (uint32)(v4)
-		f5 = (uint32)(v5)
-		f6 = (uint32)(v6)
-		f7 = (uint32)(v7)
-		f8 = (uint32)(v8)
-		f9 = (uint32)(v9)
-		f10 = (uint32)(v10)
-		f11 = (uint32)(v11)
-		f12 = (uint32)(v12)
-	}
-	return
-}

src/internal/wasi/sockets/v0.2.0/udp/empty.s

@@ -1,3 +0,0 @@
-// This file exists for testing this package without WebAssembly,
-// allowing empty function bodies with a //go:wasmimport directive.
-// See https://pkg.go.dev/cmd/compile for more information.

src/internal/wasi/sockets/v0.2.0/udp/udp.wit.go

@@ -1,643 +0,0 @@
-// Code generated by wit-bindgen-go. DO NOT EDIT.
-
-//go:build !wasip1
-
-// Package udp represents the imported interface "wasi:sockets/udp@0.2.0".
-package udp
-
-import (
-	"github.com/ydnar/wasm-tools-go/cm"
-	"internal/wasi/io/v0.2.0/poll"
-	"internal/wasi/sockets/v0.2.0/network"
-)
-
-// IncomingDatagram represents the record "wasi:sockets/udp@0.2.0#incoming-datagram".
-//
-// A received datagram.
-//
-//	record incoming-datagram {
-//		data: list<u8>,
-//		remote-address: ip-socket-address,
-//	}
-type IncomingDatagram struct {
-	// The payload.
-	//
-	// Theoretical max size: ~64 KiB. In practice, typically less than 1500 bytes.
-	Data cm.List[uint8]
-
-	// The source address.
-	//
-	// This field is guaranteed to match the remote address the stream was initialized
-	// with, if any.
-	//
-	// Equivalent to the `src_addr` out parameter of `recvfrom`.
-	RemoteAddress network.IPSocketAddress
-}
-
-// OutgoingDatagram represents the record "wasi:sockets/udp@0.2.0#outgoing-datagram".
-//
-// A datagram to be sent out.
-//
-//	record outgoing-datagram {
-//		data: list<u8>,
-//		remote-address: option<ip-socket-address>,
-//	}
-type OutgoingDatagram struct {
-	// The payload.
-	Data cm.List[uint8]
-
-	// The destination address.
-	//
-	// The requirements on this field depend on how the stream was initialized:
-	// - with a remote address: this field must be None or match the stream's remote address
-	// exactly.
-	// - without a remote address: this field is required.
-	//
-	// If this value is None, the send operation is equivalent to `send` in POSIX. Otherwise
-	// it is equivalent to `sendto`.
-	RemoteAddress cm.Option[network.IPSocketAddress]
-}
-
-// UDPSocket represents the imported resource "wasi:sockets/udp@0.2.0#udp-socket".
-//
-// A UDP socket handle.
-//
-//	resource udp-socket
-type UDPSocket cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "udp-socket".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self UDPSocket) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]udp-socket
-//go:noescape
-func wasmimport_UDPSocketResourceDrop(self0 uint32)
-
-// AddressFamily represents the imported method "address-family".
-//
-// Whether this is a IPv4 or IPv6 socket.
-//
-// Equivalent to the SO_DOMAIN socket option.
-//
-//	address-family: func() -> ip-address-family
-//
-//go:nosplit
-func (self UDPSocket) AddressFamily() (result network.IPAddressFamily) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_UDPSocketAddressFamily((uint32)(self0))
-	result = (network.IPAddressFamily)((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.address-family
-//go:noescape
-func wasmimport_UDPSocketAddressFamily(self0 uint32) (result0 uint32)
-
-// FinishBind represents the imported method "finish-bind".
-//
-//	finish-bind: func() -> result<_, error-code>
-//
-//go:nosplit
-func (self UDPSocket) FinishBind() (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketFinishBind((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.finish-bind
-//go:noescape
-func wasmimport_UDPSocketFinishBind(self0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// LocalAddress represents the imported method "local-address".
-//
-// Get the current bound address.
-//
-// POSIX mentions:
-// > If the socket has not been bound to a local name, the value
-// > stored in the object pointed to by `address` is unspecified.
-//
-// WASI is stricter and requires `local-address` to return `invalid-state` when the
-// socket hasn't been bound yet.
-//
-// # Typical errors
-// - `invalid-state`: The socket is not bound to any local address.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getsockname.html>
-// - <https://man7.org/linux/man-pages/man2/getsockname.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getsockname>
-// - <https://man.freebsd.org/cgi/man.cgi?getsockname>
-//
-//	local-address: func() -> result<ip-socket-address, error-code>
-//
-//go:nosplit
-func (self UDPSocket) LocalAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketLocalAddress((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.local-address
-//go:noescape
-func wasmimport_UDPSocketLocalAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
-// ReceiveBufferSize represents the imported method "receive-buffer-size".
-//
-// The kernel buffer space reserved for sends/receives on this socket.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-// Any other value will never cause an error, but it might be silently clamped and/or
-// rounded.
-// I.e. after setting a value, reading the same setting back may return a different
-// value.
-//
-// Equivalent to the SO_RCVBUF and SO_SNDBUF socket options.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The provided value was 0.
-//
-//	receive-buffer-size: func() -> result<u64, error-code>
-//
-//go:nosplit
-func (self UDPSocket) ReceiveBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketReceiveBufferSize((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.receive-buffer-size
-//go:noescape
-func wasmimport_UDPSocketReceiveBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// RemoteAddress represents the imported method "remote-address".
-//
-// Get the address the socket is currently streaming to.
-//
-// # Typical errors
-// - `invalid-state`: The socket is not streaming to a specific remote address. (ENOTCONN)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/getpeername.html>
-// - <https://man7.org/linux/man-pages/man2/getpeername.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-getpeername>
-// - <https://man.freebsd.org/cgi/man.cgi?query=getpeername&sektion=2&n=1>
-//
-//	remote-address: func() -> result<ip-socket-address, error-code>
-//
-//go:nosplit
-func (self UDPSocket) RemoteAddress() (result cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketRemoteAddress((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.remote-address
-//go:noescape
-func wasmimport_UDPSocketRemoteAddress(self0 uint32, result *cm.Result[IPSocketAddressShape, network.IPSocketAddress, network.ErrorCode])
-
-// SendBufferSize represents the imported method "send-buffer-size".
-//
-//	send-buffer-size: func() -> result<u64, error-code>
-//
-//go:nosplit
-func (self UDPSocket) SendBufferSize() (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketSendBufferSize((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.send-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSendBufferSize(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// SetReceiveBufferSize represents the imported method "set-receive-buffer-size".
-//
-//	set-receive-buffer-size: func(value: u64) -> result<_, error-code>
-//
-//go:nosplit
-func (self UDPSocket) SetReceiveBufferSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_UDPSocketSetReceiveBufferSize((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-receive-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSetReceiveBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetSendBufferSize represents the imported method "set-send-buffer-size".
-//
-//	set-send-buffer-size: func(value: u64) -> result<_, error-code>
-//
-//go:nosplit
-func (self UDPSocket) SetSendBufferSize(value uint64) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint64)(value)
-	wasmimport_UDPSocketSetSendBufferSize((uint32)(self0), (uint64)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-send-buffer-size
-//go:noescape
-func wasmimport_UDPSocketSetSendBufferSize(self0 uint32, value0 uint64, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// SetUnicastHopLimit represents the imported method "set-unicast-hop-limit".
-//
-//	set-unicast-hop-limit: func(value: u8) -> result<_, error-code>
-//
-//go:nosplit
-func (self UDPSocket) SetUnicastHopLimit(value uint8) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	value0 := (uint32)(value)
-	wasmimport_UDPSocketSetUnicastHopLimit((uint32)(self0), (uint32)(value0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.set-unicast-hop-limit
-//go:noescape
-func wasmimport_UDPSocketSetUnicastHopLimit(self0 uint32, value0 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// StartBind represents the imported method "start-bind".
-//
-// Bind the socket to a specific network on the provided IP address and port.
-//
-// If the IP address is zero (`0.0.0.0` in IPv4, `::` in IPv6), it is left to the
-// implementation to decide which
-// network interface(s) to bind to.
-// If the port is zero, the socket will be bound to a random free port.
-//
-// # Typical errors
-// - `invalid-argument`:          The `local-address` has the wrong address family.
-// (EAFNOSUPPORT, EFAULT on Windows)
-// - `invalid-state`:             The socket is already bound. (EINVAL)
-// - `address-in-use`:            No ephemeral ports available. (EADDRINUSE, ENOBUFS
-// on Windows)
-// - `address-in-use`:            Address is already in use. (EADDRINUSE)
-// - `address-not-bindable`:      `local-address` is not an address that the `network`
-// can bind to. (EADDRNOTAVAIL)
-// - `not-in-progress`:           A `bind` operation is not in progress.
-// - `would-block`:               Can't finish the operation, it is still in progress.
-// (EWOULDBLOCK, EAGAIN)
-//
-// # Implementors note
-// Unlike in POSIX, in WASI the bind operation is async. This enables
-// interactive WASI hosts to inject permission prompts. Runtimes that
-// don't want to make use of this ability can simply call the native
-// `bind` as part of either `start-bind` or `finish-bind`.
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/bind.html>
-// - <https://man7.org/linux/man-pages/man2/bind.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-bind>
-// - <https://man.freebsd.org/cgi/man.cgi?query=bind&sektion=2&format=html>
-//
-//	start-bind: func(network: borrow<network>, local-address: ip-socket-address) ->
-//	result<_, error-code>
-//
-//go:nosplit
-func (self UDPSocket) StartBind(network_ network.Network, localAddress network.IPSocketAddress) (result cm.Result[network.ErrorCode, struct{}, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	network0 := cm.Reinterpret[uint32](network_)
-	localAddress0, localAddress1, localAddress2, localAddress3, localAddress4, localAddress5, localAddress6, localAddress7, localAddress8, localAddress9, localAddress10, localAddress11 := lower_IPSocketAddress(localAddress)
-	wasmimport_UDPSocketStartBind((uint32)(self0), (uint32)(network0), (uint32)(localAddress0), (uint32)(localAddress1), (uint32)(localAddress2), (uint32)(localAddress3), (uint32)(localAddress4), (uint32)(localAddress5), (uint32)(localAddress6), (uint32)(localAddress7), (uint32)(localAddress8), (uint32)(localAddress9), (uint32)(localAddress10), (uint32)(localAddress11), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.start-bind
-//go:noescape
-func wasmimport_UDPSocketStartBind(self0 uint32, network0 uint32, localAddress0 uint32, localAddress1 uint32, localAddress2 uint32, localAddress3 uint32, localAddress4 uint32, localAddress5 uint32, localAddress6 uint32, localAddress7 uint32, localAddress8 uint32, localAddress9 uint32, localAddress10 uint32, localAddress11 uint32, result *cm.Result[network.ErrorCode, struct{}, network.ErrorCode])
-
-// Stream represents the imported method "stream".
-//
-// Set up inbound & outbound communication channels, optionally to a specific peer.
-//
-// This function only changes the local socket configuration and does not generate
-// any network traffic.
-// On success, the `remote-address` of the socket is updated. The `local-address`
-// may be updated as well,
-// based on the best network path to `remote-address`.
-//
-// When a `remote-address` is provided, the returned streams are limited to communicating
-// with that specific peer:
-// - `send` can only be used to send to this destination.
-// - `receive` will only return datagrams sent from the provided `remote-address`.
-//
-// This method may be called multiple times on the same socket to change its association,
-// but
-// only the most recently returned pair of streams will be operational. Implementations
-// may trap if
-// the streams returned by a previous invocation haven't been dropped yet before calling
-// `stream` again.
-//
-// The POSIX equivalent in pseudo-code is:
-//
-//	if (was previously connected) {
-//	connect(s, AF_UNSPEC)
-//	}
-//	if (remote_address is Some) {
-//	connect(s, remote_address)
-//	}
-//
-// Unlike in POSIX, the socket must already be explicitly bound.
-//
-// # Typical errors
-// - `invalid-argument`:          The `remote-address` has the wrong address family.
-// (EAFNOSUPPORT)
-// - `invalid-argument`:          The IP address in `remote-address` is set to INADDR_ANY
-// (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-// - `invalid-argument`:          The port in `remote-address` is set to 0. (EDESTADDRREQ,
-// EADDRNOTAVAIL)
-// - `invalid-state`:             The socket is not bound.
-// - `address-in-use`:            Tried to perform an implicit bind, but there were
-// no ephemeral ports available. (EADDRINUSE, EADDRNOTAVAIL on Linux, EAGAIN on BSD)
-// - `remote-unreachable`:        The remote address is not reachable. (ECONNRESET,
-// ENETRESET, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
-// - `connection-refused`:        The connection was refused. (ECONNREFUSED)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/connect.html>
-// - <https://man7.org/linux/man-pages/man2/connect.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-connect>
-// - <https://man.freebsd.org/cgi/man.cgi?connect>
-//
-//	%stream: func(remote-address: option<ip-socket-address>) -> result<tuple<incoming-datagram-stream,
-//	outgoing-datagram-stream>, error-code>
-//
-//go:nosplit
-func (self UDPSocket) Stream(remoteAddress cm.Option[network.IPSocketAddress]) (result cm.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	remoteAddress0, remoteAddress1, remoteAddress2, remoteAddress3, remoteAddress4, remoteAddress5, remoteAddress6, remoteAddress7, remoteAddress8, remoteAddress9, remoteAddress10, remoteAddress11, remoteAddress12 := lower_OptionIPSocketAddress(remoteAddress)
-	wasmimport_UDPSocketStream((uint32)(self0), (uint32)(remoteAddress0), (uint32)(remoteAddress1), (uint32)(remoteAddress2), (uint32)(remoteAddress3), (uint32)(remoteAddress4), (uint32)(remoteAddress5), (uint32)(remoteAddress6), (uint32)(remoteAddress7), (uint32)(remoteAddress8), (uint32)(remoteAddress9), (uint32)(remoteAddress10), (uint32)(remoteAddress11), (uint32)(remoteAddress12), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.stream
-//go:noescape
-func wasmimport_UDPSocketStream(self0 uint32, remoteAddress0 uint32, remoteAddress1 uint32, remoteAddress2 uint32, remoteAddress3 uint32, remoteAddress4 uint32, remoteAddress5 uint32, remoteAddress6 uint32, remoteAddress7 uint32, remoteAddress8 uint32, remoteAddress9 uint32, remoteAddress10 uint32, remoteAddress11 uint32, remoteAddress12 uint32, result *cm.Result[TupleIncomingDatagramStreamOutgoingDatagramStreamShape, cm.Tuple[IncomingDatagramStream, OutgoingDatagramStream], network.ErrorCode])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once the socket is ready for I/O.
-//
-// Note: this function is here for WASI Preview2 only.
-// It's planned to be removed when `future` is natively supported in Preview3.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self UDPSocket) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_UDPSocketSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.subscribe
-//go:noescape
-func wasmimport_UDPSocketSubscribe(self0 uint32) (result0 uint32)
-
-// UnicastHopLimit represents the imported method "unicast-hop-limit".
-//
-// Equivalent to the IP_TTL & IPV6_UNICAST_HOPS socket options.
-//
-// If the provided value is 0, an `invalid-argument` error is returned.
-//
-// # Typical errors
-// - `invalid-argument`:     (set) The TTL value must be 1 or higher.
-//
-//	unicast-hop-limit: func() -> result<u8, error-code>
-//
-//go:nosplit
-func (self UDPSocket) UnicastHopLimit() (result cm.Result[uint8, uint8, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_UDPSocketUnicastHopLimit((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]udp-socket.unicast-hop-limit
-//go:noescape
-func wasmimport_UDPSocketUnicastHopLimit(self0 uint32, result *cm.Result[uint8, uint8, network.ErrorCode])
-
-// IncomingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#incoming-datagram-stream".
-//
-//	resource incoming-datagram-stream
-type IncomingDatagramStream cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "incoming-datagram-stream".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self IncomingDatagramStream) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_IncomingDatagramStreamResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]incoming-datagram-stream
-//go:noescape
-func wasmimport_IncomingDatagramStreamResourceDrop(self0 uint32)
-
-// Receive represents the imported method "receive".
-//
-// Receive messages on the socket.
-//
-// This function attempts to receive up to `max-results` datagrams on the socket without
-// blocking.
-// The returned list may contain fewer elements than requested, but never more.
-//
-// This function returns successfully with an empty list when either:
-// - `max-results` is 0, or:
-// - `max-results` is greater than 0, but no results are immediately available.
-// This function never returns `error(would-block)`.
-//
-// # Typical errors
-// - `remote-unreachable`: The remote address is not reachable. (ECONNRESET, ENETRESET
-// on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
-// - `connection-refused`: The connection was refused. (ECONNREFUSED)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvfrom.html>
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/recvmsg.html>
-// - <https://man7.org/linux/man-pages/man2/recv.2.html>
-// - <https://man7.org/linux/man-pages/man2/recvmmsg.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recv>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock/nf-winsock-recvfrom>
-// - <https://learn.microsoft.com/en-us/previous-versions/windows/desktop/legacy/ms741687(v=vs.85)>
-// - <https://man.freebsd.org/cgi/man.cgi?query=recv&sektion=2>
-//
-//	receive: func(max-results: u64) -> result<list<incoming-datagram>, error-code>
-//
-//go:nosplit
-func (self IncomingDatagramStream) Receive(maxResults uint64) (result cm.Result[cm.List[IncomingDatagram], cm.List[IncomingDatagram], network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	maxResults0 := (uint64)(maxResults)
-	wasmimport_IncomingDatagramStreamReceive((uint32)(self0), (uint64)(maxResults0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.receive
-//go:noescape
-func wasmimport_IncomingDatagramStreamReceive(self0 uint32, maxResults0 uint64, result *cm.Result[cm.List[IncomingDatagram], cm.List[IncomingDatagram], network.ErrorCode])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once the stream is ready to receive again.
-//
-// Note: this function is here for WASI Preview2 only.
-// It's planned to be removed when `future` is natively supported in Preview3.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self IncomingDatagramStream) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_IncomingDatagramStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]incoming-datagram-stream.subscribe
-//go:noescape
-func wasmimport_IncomingDatagramStreamSubscribe(self0 uint32) (result0 uint32)
-
-// OutgoingDatagramStream represents the imported resource "wasi:sockets/udp@0.2.0#outgoing-datagram-stream".
-//
-//	resource outgoing-datagram-stream
-type OutgoingDatagramStream cm.Resource
-
-// ResourceDrop represents the imported resource-drop for resource "outgoing-datagram-stream".
-//
-// Drops a resource handle.
-//
-//go:nosplit
-func (self OutgoingDatagramStream) ResourceDrop() {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutgoingDatagramStreamResourceDrop((uint32)(self0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [resource-drop]outgoing-datagram-stream
-//go:noescape
-func wasmimport_OutgoingDatagramStreamResourceDrop(self0 uint32)
-
-// CheckSend represents the imported method "check-send".
-//
-// Check readiness for sending. This function never blocks.
-//
-// Returns the number of datagrams permitted for the next call to `send`,
-// or an error. Calling `send` with more datagrams than this function has
-// permitted will trap.
-//
-// When this function returns ok(0), the `subscribe` pollable will
-// become ready when this function will report at least ok(1), or an
-// error.
-//
-// Never returns `would-block`.
-//
-//	check-send: func() -> result<u64, error-code>
-//
-//go:nosplit
-func (self OutgoingDatagramStream) CheckSend() (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	wasmimport_OutgoingDatagramStreamCheckSend((uint32)(self0), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.check-send
-//go:noescape
-func wasmimport_OutgoingDatagramStreamCheckSend(self0 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// Send represents the imported method "send".
-//
-// Send messages on the socket.
-//
-// This function attempts to send all provided `datagrams` on the socket without blocking
-// and
-// returns how many messages were actually sent (or queued for sending). This function
-// never
-// returns `error(would-block)`. If none of the datagrams were able to be sent, `ok(0)`
-// is returned.
-//
-// This function semantically behaves the same as iterating the `datagrams` list and
-// sequentially
-// sending each individual datagram until either the end of the list has been reached
-// or the first error occurred.
-// If at least one datagram has been sent successfully, this function never returns
-// an error.
-//
-// If the input list is empty, the function returns `ok(0)`.
-//
-// Each call to `send` must be permitted by a preceding `check-send`. Implementations
-// must trap if
-// either `check-send` was not called or `datagrams` contains more items than `check-send`
-// permitted.
-//
-// # Typical errors
-// - `invalid-argument`:        The `remote-address` has the wrong address family.
-// (EAFNOSUPPORT)
-// - `invalid-argument`:        The IP address in `remote-address` is set to INADDR_ANY
-// (`0.0.0.0` / `::`). (EDESTADDRREQ, EADDRNOTAVAIL)
-// - `invalid-argument`:        The port in `remote-address` is set to 0. (EDESTADDRREQ,
-// EADDRNOTAVAIL)
-// - `invalid-argument`:        The socket is in "connected" mode and `remote-address`
-// is `some` value that does not match the address passed to `stream`. (EISCONN)
-// - `invalid-argument`:        The socket is not "connected" and no value for `remote-address`
-// was provided. (EDESTADDRREQ)
-// - `remote-unreachable`:      The remote address is not reachable. (ECONNRESET,
-// ENETRESET on Windows, EHOSTUNREACH, EHOSTDOWN, ENETUNREACH, ENETDOWN, ENONET)
-// - `connection-refused`:      The connection was refused. (ECONNREFUSED)
-// - `datagram-too-large`:      The datagram is too large. (EMSGSIZE)
-//
-// # References
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendto.html>
-// - <https://pubs.opengroup.org/onlinepubs/9699919799/functions/sendmsg.html>
-// - <https://man7.org/linux/man-pages/man2/send.2.html>
-// - <https://man7.org/linux/man-pages/man2/sendmmsg.2.html>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-send>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-sendto>
-// - <https://learn.microsoft.com/en-us/windows/win32/api/winsock2/nf-winsock2-wsasendmsg>
-// - <https://man.freebsd.org/cgi/man.cgi?query=send&sektion=2>
-//
-//	send: func(datagrams: list<outgoing-datagram>) -> result<u64, error-code>
-//
-//go:nosplit
-func (self OutgoingDatagramStream) Send(datagrams cm.List[OutgoingDatagram]) (result cm.Result[uint64, uint64, network.ErrorCode]) {
-	self0 := cm.Reinterpret[uint32](self)
-	datagrams0, datagrams1 := cm.LowerList(datagrams)
-	wasmimport_OutgoingDatagramStreamSend((uint32)(self0), (*OutgoingDatagram)(datagrams0), (uint32)(datagrams1), &result)
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.send
-//go:noescape
-func wasmimport_OutgoingDatagramStreamSend(self0 uint32, datagrams0 *OutgoingDatagram, datagrams1 uint32, result *cm.Result[uint64, uint64, network.ErrorCode])
-
-// Subscribe represents the imported method "subscribe".
-//
-// Create a `pollable` which will resolve once the stream is ready to send again.
-//
-// Note: this function is here for WASI Preview2 only.
-// It's planned to be removed when `future` is natively supported in Preview3.
-//
-//	subscribe: func() -> pollable
-//
-//go:nosplit
-func (self OutgoingDatagramStream) Subscribe() (result poll.Pollable) {
-	self0 := cm.Reinterpret[uint32](self)
-	result0 := wasmimport_OutgoingDatagramStreamSubscribe((uint32)(self0))
-	result = cm.Reinterpret[poll.Pollable]((uint32)(result0))
-	return
-}
-
-//go:wasmimport wasi:sockets/udp@0.2.0 [method]outgoing-datagram-stream.subscribe
-//go:noescape
-func wasmimport_OutgoingDatagramStreamSubscribe(self0 uint32) (result0 uint32)

src/machine/board_nanoch32v003.go

@@ -0,0 +1,5 @@
+//go:build nanoch32v003
+
+package machine
+
+const LED = PD6

src/machine/machine_ch32v003.go

@@ -0,0 +1,72 @@
+//go:build ch32v003
+
+package machine
+
+import "device/wch"
+
+const deviceName = wch.Device
+
+const (
+	PA0 Pin = 0 + 0
+	PA1 Pin = 0 + 1
+	PA2 Pin = 0 + 2
+	PA3 Pin = 0 + 3
+	PA4 Pin = 0 + 4
+	PA5 Pin = 0 + 5
+	PA6 Pin = 0 + 6
+	PA7 Pin = 0 + 7
+	PC0 Pin = 16 + 0
+	PC1 Pin = 16 + 1
+	PC2 Pin = 16 + 2
+	PC3 Pin = 16 + 3
+	PC4 Pin = 16 + 4
+	PC5 Pin = 16 + 5
+	PC6 Pin = 16 + 6
+	PC7 Pin = 16 + 7
+	PD0 Pin = 24 + 0
+	PD1 Pin = 24 + 1
+	PD2 Pin = 24 + 2
+	PD3 Pin = 24 + 3
+	PD4 Pin = 24 + 4
+	PD5 Pin = 24 + 5
+	PD6 Pin = 24 + 6
+	PD7 Pin = 24 + 7
+)
+
+const (
+	PinInput  PinMode = 0
+	PinOutput PinMode = 3
+)
+
+func (p Pin) getPortPin() (port *wch.GPIO_Type, pin uint32) {
+	portNum := uint32(p) >> 3
+	pin = uint32(p) & 0b111
+	switch portNum {
+	case 0:
+		port = wch.GPIOA
+	case 2:
+		port = wch.GPIOC
+	case 3:
+		port = wch.GPIOD
+	}
+	return
+}
+
+func (p Pin) Configure(config PinConfig) {
+	port, pin := p.getPortPin()
+	reg := port.CFGLR.Get()
+	reg &^= (0xf << (4 * pin))
+	reg |= 0b0000 << (4 * pin)
+	reg |= 0b11 << (4 * pin)
+	port.CFGLR.Set(reg)
+}
+
+// Set the pin to high or low.
+func (p Pin) Set(high bool) {
+	port, pin := p.getPortPin()
+	if high {
+		port.BSHR.Set(1 << pin)
+	} else {
+		port.BCR.Set(1 << pin)
+	}
+}

src/os/dir_other.go

@@ -1,4 +1,4 @@
-//go:build baremetal || js || windows || wasm_unknown
+//go:build baremetal || js || windows
 
 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style