deps: updates TinyGo to v0.28.1 (#28)

Signed-off-by: Adrian Cole <adrian@tetrate.io>

Author: codefromthecrypt

.github/workflows/commit.yaml

@@ -52,7 +52,7 @@ jobs:
         go-version:  # Note: Go only supports 2 versions: https://go.dev/doc/devel/release#policy
           - "1.20"
         tinygo-version:  # Note: TinyGo only supports latest: https://github.com/tinygo-org/tinygo/releases
-          - "0.27.0"  # Latest
+          - "0.28.1"  # Latest
 
     steps:
       - uses: actions/checkout@v3

.github/workflows/testdata.yaml

@@ -29,7 +29,7 @@ jobs:
         go-version:  # Note: Go only supports 2 versions: https://go.dev/doc/devel/release#policy
           - "1.20"
         tinygo-version:  # Note: TinyGo only supports latest: https://github.com/tinygo-org/tinygo/releases
-          - "0.27.0"  # Latest
+          - "0.28.1"  # Latest
 
     steps:
       - uses: actions/checkout@v3

README.md

@@ -40,7 +40,7 @@ func handleRequest(req api.Request, resp api.Response) (next bool, reqCtx uint32
 }
 ```
 
-If you make changes, you can rebuild it like so:
+If you make changes, you can rebuild this with TinyGo v0.28 or higher like so:
 ```sh
 tinygo build -o examples/router/main.wasm -scheduler=none --no-debug -target=wasi examples/router/main.go
 ```

examples/router/main.wasm

@@ -1,6 +1,3 @@
 module github.com/http-wasm/http-wasm-guest-tinygo
 
-// TinyGo 0.27 doesn't fully support Go 1.20, but it supports what we need.
-// Particularly, unsafe.SliceData, unsafe.StringData were added to TinyGo 0.27.
-// See https://github.com/tinygo-org/tinygo/commit/c43958972c3ffcd51e65414a346e53779edb9f97
 go 1.20

examples/wasi/main.wasm

@@ -45,12 +45,12 @@ func (b wasmBody) Read(bytes []byte) (size uint32, eof bool) {
 		return // invalid, but prevent crashing.
 	}
 
-	size, eof = read(b, uintptr(ptr), limit)
+	size, eof = read(b, ptr, limit)
 	runtime.KeepAlive(bytes) // keep bytes alive until ptr is no longer needed.
 	return
 }
 
-func read(b wasmBody, ptr uintptr, limit imports.BufLimit) (size uint32, eof bool) {
+func read(b wasmBody, ptr uint32, limit imports.BufLimit) (size uint32, eof bool) {
 	eofLen := imports.ReadBody(imports.BodyKind(b), ptr, limit)
 	eof = (eofLen >> 32) == 1
 	size = uint32(eofLen)
@@ -64,7 +64,7 @@ func (b wasmBody) Write(bytes []byte) {
 		return
 	}
 
-	imports.WriteBody(imports.BodyKind(b), uintptr(ptr), size)
+	imports.WriteBody(imports.BodyKind(b), ptr, size)
 	runtime.KeepAlive(bytes) // keep bytes alive until ptr is no longer needed.
 }
 
@@ -75,6 +75,6 @@ func (b wasmBody) WriteString(s string) {
 		return
 	}
 
-	imports.WriteBody(imports.BodyKind(b), uintptr(ptr), size)
+	imports.WriteBody(imports.BodyKind(b), ptr, size)
 	runtime.KeepAlive(s) // keep s alive until ptr is no longer needed.
 }

go.mod

@@ -31,8 +31,8 @@ func (w wasmHeader) Names() (names []string) {
 	}
 	// Otherwise, we have to allocate a new buffer for the large entry.
 	buf := make([]byte, size)
-	ptr := unsafe.Pointer(unsafe.SliceData(buf))
-	_ = imports.GetHeaderNames(imports.HeaderKind(w), uintptr(ptr), size)
+	ptr := uint32(uintptr(unsafe.Pointer(unsafe.SliceData(buf))))
+	_ = imports.GetHeaderNames(imports.HeaderKind(w), ptr, size)
 	names = mem.GetNULTerminated(buf)
 	runtime.KeepAlive(buf) // keep buf alive until ptr is no longer needed.
 	return
@@ -51,7 +51,7 @@ func (w wasmHeader) Get(name string) (value string, ok bool) {
 // GetAll implements the same method as documented on api.Request.
 func (w wasmHeader) GetAll(name string) (names []string) {
 	namePtr, nameSize := mem.StringToPtr(name)
-	countLen := imports.GetHeaderValues(imports.HeaderKind(w), uintptr(namePtr), nameSize, mem.ReadBufPtr, mem.ReadBufLimit)
+	countLen := imports.GetHeaderValues(imports.HeaderKind(w), namePtr, nameSize, mem.ReadBufPtr, mem.ReadBufLimit)
 	runtime.KeepAlive(name) // keep name alive until ptr is no longer needed.
 	if countLen == 0 {
 		return
@@ -66,8 +66,8 @@ func (w wasmHeader) GetAll(name string) (names []string) {
 	}
 	// Otherwise, we have to allocate a new buffer for the large entry.
 	buf := make([]byte, size)
-	ptr := unsafe.Pointer(unsafe.SliceData(buf))
-	_ = imports.GetHeaderValues(imports.HeaderKind(w), uintptr(namePtr), nameSize, uintptr(ptr), size)
+	ptr := uint32(uintptr(unsafe.Pointer(unsafe.SliceData(buf))))
+	_ = imports.GetHeaderValues(imports.HeaderKind(w), namePtr, nameSize, ptr, size)
 	names = mem.GetNULTerminated(buf)
 	runtime.KeepAlive(name) // keep name alive until ptr is no longer needed.
 	runtime.KeepAlive(buf)  // keep buf alive until ptr is no longer needed.
@@ -78,7 +78,7 @@ func (w wasmHeader) GetAll(name string) (names []string) {
 func (w wasmHeader) Set(name, value string) {
 	namePtr, nameSize := mem.StringToPtr(name)
 	valuePtr, valueSize := mem.StringToPtr(value)
-	imports.SetHeaderValue(imports.HeaderKind(w), uintptr(namePtr), nameSize, uintptr(valuePtr), valueSize)
+	imports.SetHeaderValue(imports.HeaderKind(w), namePtr, nameSize, valuePtr, valueSize)
 	runtime.KeepAlive(name)  // keep name alive until ptr is no longer needed.
 	runtime.KeepAlive(value) // keep value alive until ptr is no longer needed.
 }
@@ -87,14 +87,14 @@ func (w wasmHeader) Set(name, value string) {
 func (w wasmHeader) Add(name, value string) {
 	namePtr, nameSize := mem.StringToPtr(name)
 	valuePtr, valueSize := mem.StringToPtr(value)
-	imports.AddHeaderValue(imports.HeaderKind(w), uintptr(namePtr), nameSize, uintptr(valuePtr), valueSize)
+	imports.AddHeaderValue(imports.HeaderKind(w), namePtr, nameSize, valuePtr, valueSize)
 	runtime.KeepAlive(name)  // keep name alive until ptr is no longer needed.
 	runtime.KeepAlive(value) // keep value alive until ptr is no longer needed.
 }
 
 // Remove implements the same method as documented on api.Request.
 func (w wasmHeader) Remove(name string) {
 	namePtr, nameSize := mem.StringToPtr(name)
-	imports.RemoveHeader(imports.HeaderKind(w), uintptr(namePtr), nameSize)
+	imports.RemoveHeader(imports.HeaderKind(w), namePtr, nameSize)
 	runtime.KeepAlive(name) // keep name alive until ptr is no longer needed.
 }

handler/body.go

@@ -38,6 +38,6 @@ func (wasmHost) Log(level api.LogLevel, message string) {
 		return // don't incur host call overhead
 	}
 	ptr, size := mem.StringToPtr(message)
-	imports.Log(level, uintptr(ptr), size)
+	imports.Log(level, ptr, size)
 	runtime.KeepAlive(message) // keep message alive until ptr is no longer needed.
 }

handler/header.go

@@ -111,63 +111,63 @@ func EnableFeatures(features api.Features) api.Features {
 	return enableFeatures(features)
 }
 
-func GetConfig(ptr uintptr, limit BufLimit) (len uint32) {
+func GetConfig(ptr uint32, limit BufLimit) (len uint32) {
 	return getConfig(ptr, limit)
 }
 
 func LogEnabled(level api.LogLevel) uint32 {
 	return logEnabled(level)
 }
 
-func Log(level api.LogLevel, ptr uintptr, size uint32) {
+func Log(level api.LogLevel, ptr, size uint32) {
 	log(level, ptr, size)
 }
 
-func GetMethod(ptr uintptr, limit BufLimit) (len uint32) {
+func GetMethod(ptr uint32, limit BufLimit) (len uint32) {
 	return getMethod(ptr, limit)
 }
 
-func SetMethod(ptr uintptr, size uint32) {
+func SetMethod(ptr, size uint32) {
 	setMethod(ptr, size)
 }
 
-func GetURI(ptr uintptr, limit BufLimit) (len uint32) {
+func GetURI(ptr uint32, limit BufLimit) (len uint32) {
 	return getURI(ptr, limit)
 }
 
-func SetURI(ptr uintptr, size uint32) {
+func SetURI(ptr, size uint32) {
 	setURI(ptr, size)
 }
 
-func GetProtocolVersion(ptr uintptr, limit BufLimit) (len uint32) {
+func GetProtocolVersion(ptr uint32, limit BufLimit) (len uint32) {
 	return getProtocolVersion(ptr, limit)
 }
 
-func GetHeaderNames(kind HeaderKind, ptr uintptr, limit BufLimit) CountLen {
+func GetHeaderNames(kind HeaderKind, ptr uint32, limit BufLimit) CountLen {
 	return getHeaderNames(kind, ptr, limit)
 }
 
-func GetHeaderValues(kind HeaderKind, namePtr uintptr, nameSize uint32, bufPtr uintptr, bufLimit BufLimit) CountLen {
+func GetHeaderValues(kind HeaderKind, namePtr, nameSize uint32, bufPtr uint32, bufLimit BufLimit) CountLen {
 	return getHeaderValues(kind, namePtr, nameSize, bufPtr, bufLimit)
 }
 
-func SetHeaderValue(kind HeaderKind, namePtr uintptr, nameSize uint32, valuePtr uintptr, valueSize uint32) {
+func SetHeaderValue(kind HeaderKind, namePtr, nameSize uint32, valuePtr uint32, valueSize uint32) {
 	setHeaderValue(kind, namePtr, nameSize, valuePtr, valueSize)
 }
 
-func AddHeaderValue(kind HeaderKind, namePtr uintptr, nameSize uint32, valuePtr uintptr, valueSize uint32) {
+func AddHeaderValue(kind HeaderKind, namePtr, nameSize uint32, valuePtr uint32, valueSize uint32) {
 	addHeaderValue(kind, namePtr, nameSize, valuePtr, valueSize)
 }
 
-func RemoveHeader(kind HeaderKind, namePtr uintptr, nameSize uint32) {
+func RemoveHeader(kind HeaderKind, namePtr, nameSize uint32) {
 	removeHeader(kind, namePtr, nameSize)
 }
 
-func ReadBody(kind BodyKind, bufPtr uintptr, bufLimit BufLimit) EOFLen {
+func ReadBody(kind BodyKind, bufPtr uint32, bufLimit BufLimit) EOFLen {
 	return readBody(kind, bufPtr, bufLimit)
 }
 
-func WriteBody(kind BodyKind, bufPtr uintptr, bufSize uint32) {
+func WriteBody(kind BodyKind, bufPtr uint32, bufSize uint32) {
 	writeBody(kind, bufPtr, bufSize)
 }