@wasm-fmt/gofmt 0.4.9 → 0.5.0

package/README.md

@@ -2,13 +2,13 @@
 
 # Install
 
-[![npm](https://img.shields.io/npm/v/@wasm-fmt/gofmt)](https://www.npmjs.com/package/@wasm-fmt/gofmt)
+[![npm](https://img.shields.io/npm/v/@wasm-fmt/gofmt?color=00ADD8)](https://www.npmjs.com/package/@wasm-fmt/gofmt)
 
 ```bash
 npm install @wasm-fmt/gofmt
 ```
 
-[![jsr.io](https://jsr.io/badges/@fmt/gofmt)](https://jsr.io/@fmt/gofmt)
+[![jsr.io](https://jsr.io/badges/@fmt/gofmt?color=00ADD8)](https://jsr.io/@fmt/gofmt)
 
 ```bash
 npx jsr add @fmt/gofmt
@@ -41,14 +41,19 @@ import init, { format } from "@wasm-fmt/gofmt/vite";
 # Build from source
 
 ```bash
-# 1. clone this repo
-git clone https://github.com/wasm-fmt/gofmt.git
+# 1. install Go https://go.dev/doc/install
 
 # 2. install TinyGo https://tinygo.org/getting-started/install/
 
-# 3. build
-pnpm build
+# 3. clone this repo
+git clone https://github.com/wasm-fmt/gofmt.git
+
+# 4. install dependencies inside the repo
+npm install
+
+# 5. build
+npm run build
 
-# 4. test
-pnpm run /^test:/
+# 6. test
+npm run /^test:/
 ```

package/gofmt.js

@@ -1,13 +1,17 @@
+/* @ts-self-types="./gofmt.d.ts" */
 // Copyright 2018 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.
 //
 // This file has been modified for use by the TinyGo compiler.
 
+// End of polyfills for common API.
+
 	const encoder = new TextEncoder("utf-8");
 	const decoder = new TextDecoder("utf-8");
 	let reinterpretBuf = new DataView(new ArrayBuffer(8));
 	var logLine = [];
+	const wasmExit = {}; // thrown to exit via proc_exit (not an error)
 
 	class Go {
 		constructor() {
@@ -115,33 +119,78 @@
 			this.importObject = {
 				wasi_snapshot_preview1: {
 					// https://github.com/WebAssembly/WASI/blob/main/phases/snapshot/docs.md#fd_write
-					fd_write: () => 0,      // dummy
+					fd_write: function(fd, iovs_ptr, iovs_len, nwritten_ptr) {
+						let nwritten = 0;
+						if (fd == 1) {
+							for (let iovs_i=0; iovs_i<iovs_len;iovs_i++) {
+								let iov_ptr = iovs_ptr+iovs_i*8; // assuming wasm32
+								let ptr = mem().getUint32(iov_ptr + 0, true);
+								let len = mem().getUint32(iov_ptr + 4, true);
+								nwritten += len;
+								for (let i=0; i<len; i++) {
+									let c = mem().getUint8(ptr+i);
+									if (c == 13) { // CR
+										// ignore
+									} else if (c == 10) { // LF
+										// write line
+										let line = decoder.decode(new Uint8Array(logLine));
+										logLine = [];
+										console.log(line);
+									} else {
+										logLine.push(c);
+									}
+								}
+							}
+						} else {
+							console.error('invalid file descriptor:', fd);
+						}
+						mem().setUint32(nwritten_ptr, nwritten, true);
+						return 0;
+					},
+					/* removed fd_close */      // dummy
+					/* removed fd_fdstat_get */ // dummy
+					/* removed fd_seek */       // dummy
+					proc_exit: (code) => {
+						this.exited = true;
+						this.exitCode = code;
+						this._resolveExitPromise();
+						throw wasmExit;
+					},
+					random_get: (bufPtr, bufLen) => {
+						crypto.getRandomValues(loadSlice(bufPtr, bufLen));
+						return 0;
+					},
 				},
 				gojs: {
-					// func ticks() float64
+					// func ticks() int64
 					"runtime.ticks": () => {
-						return timeOrigin + performance.now();
+						return BigInt((timeOrigin + performance.now()) * 1e6);
 					},
 
+					// func sleepTicks(timeout int64)
+					/* removed runtime.sleepTicks */
+
 					// func finalizeRef(v ref)
 					"syscall/js.finalizeRef": (v_ref) => {
-						reinterpretBuf.setBigInt64(0, v_ref, true);
-						const f = reinterpretBuf.getFloat64(0, true);
-						if (f === 0 || !isNaN(f)) {
-							return;
-						}
+						// Note: TinyGo does not support finalizers so this is only called
+						// for one specific case, by js.go:jsString. and can/might leak memory.
 						const id = v_ref & 0xffffffffn;
-						this._goRefCounts[id]--;
-						if (this._goRefCounts[id] === 0) {
-							const v = this._values[id];
-							this._values[id] = null;
-							this._ids.delete(v);
-							this._idPool.push(id);
+						if (this._goRefCounts?.[id] !== undefined) {
+							this._goRefCounts[id]--;
+							if (this._goRefCounts[id] === 0) {
+								const v = this._values[id];
+								this._values[id] = null;
+								this._ids.delete(v);
+								this._idPool.push(id);
+							}
+						} else {
+							console.error("syscall/js.finalizeRef: unknown id", id);
 						}
 					},
 
 					// func stringVal(value string) ref
 					"syscall/js.stringVal": (value_ptr, value_len) => {
+						value_ptr >>>= 0;
 						const s = loadString(value_ptr, value_len);
 						return boxValue(s);
 					},
@@ -162,6 +211,9 @@
 						Reflect.set(v, p, x);
 					},
 
+					// func valueDelete(v ref, p string)
+					/* removed syscall/js.valueDelete */
+
 					// func valueIndex(v ref, i int) ref
 					"syscall/js.valueIndex": (v_ref, i) => {
 						return boxValue(Reflect.get(unboxValue(v_ref), i));
@@ -187,6 +239,9 @@
 						}
 					},
 
+					// func valueInvoke(v ref, args []ref) (ref, bool)
+					/* removed syscall/js.valueInvoke */
+
 					// func valueNew(v ref, args []ref) (ref, bool)
 					"syscall/js.valueNew": (ret_addr, v_ref, args_ptr, args_len, args_cap) => {
 						const v = unboxValue(v_ref);
@@ -218,6 +273,17 @@
 						const str = unboxValue(v_ref);
 						loadSlice(slice_ptr, slice_len, slice_cap).set(str);
 					},
+
+					// func valueInstanceOf(v ref, t ref) bool
+					/* removed syscall/js.valueInstanceOf */
+
+					// func copyBytesToGo(dst []byte, src ref) (int, bool)
+					/* removed syscall/js.copyBytesToGo */
+
+					// copyBytesToJS(dst ref, src []byte) (int, bool)
+					// Originally copied from upstream Go project, then modified:
+					//   https://github.com/golang/go/blob/3f995c3f3b43033013013e6c7ccc93a9b1411ca9/misc/wasm/wasm_exec.js#L404-L416
+					/* removed syscall/js.copyBytesToJS */
 				}
 			};
 
@@ -234,33 +300,32 @@
 				null,
 				true,
 				false,
-				// fake global
-				{
-					set format(fn){ instance.format = fn; },
-					Array,
-					Object,
-				},
+				/* fake global */ { set format(fn) { instance.format = fn }, Array, Object},
 				this,
 			];
 			this._goRefCounts = []; // number of references that Go has to a JS value, indexed by reference id
 			this._ids = new Map();  // mapping from JS values to reference ids
 			this._idPool = [];      // unused ids that have been garbage collected
 			this.exited = false;    // whether the Go program has exited
+			this.exitCode = 0;
 
-			while (true) {
-				const callbackPromise = new Promise((resolve) => {
-					this._resolveCallbackPromise = () => {
-						if (this.exited) {
-							throw new Error("bad callback: Go program has already exited");
-						}
-						setTimeout(resolve, 0); // make sure it is asynchronous
-					};
+			if (this._inst.exports._start) {
+				let exitPromise = new Promise((resolve, reject) => {
+					this._resolveExitPromise = resolve;
 				});
-				this._inst.exports._start();
-				if (this.exited) {
-					break;
+
+				// Run program, but catch the wasmExit exception that's thrown
+				// to return back here.
+				try {
+					this._inst.exports._start();
+				} catch (e) {
+					if (e !== wasmExit) throw e;
 				}
-				await callbackPromise;
+
+				await exitPromise;
+				return this.exitCode;
+			} else {
+				this._inst.exports._initialize();
 			}
 		}
 
@@ -268,7 +333,11 @@
 			if (this.exited) {
 				throw new Error("Go program has already exited");
 			}
-			this._inst.exports.resume();
+			try {
+				this._inst.exports.resume();
+			} catch (e) {
+				if (e !== wasmExit) throw e;
+			}
 			if (this.exited) {
 				this._resolveExitPromise();
 			}
@@ -284,72 +353,83 @@
 			};
 		}
 	}
-
 /**
  * ================== End of wasm_exec.js ==================
  */
-/**/let wasm;
-/**/async function __load(module, imports) {
-/**/	if (typeof Response === 'function' && module instanceof Response) {
-/**/		if (typeof WebAssembly.instantiateStreaming === 'function') {
-/**/			try { return await WebAssembly.instantiateStreaming(module, imports); }
-/**/			catch (e) {
-/**/				if (module.headers.get('Content-Type') != 'application/wasm') {
-/**/					console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
-/**/				} else { throw e; }
-/**/			}
-/**/		}
-/**/		const bytes = await module.arrayBuffer();
-/**/		return await WebAssembly.instantiate(bytes, imports);
-/**/	} else {
-/**/		const instance = await WebAssembly.instantiate(module, imports);
-/**/		if (instance instanceof WebAssembly.Instance) return { instance, module };
-/**/		else return instance;
-/**/	}
-/**/}
-/**/function __finalize_init(instance) {
-/**/	return wasm = instance;
-/**/}
-/**/function __init_memory(imports, maybe_memory) { }
-/**/export function initSync(module) {
-/**/	if (wasm !== undefined) return wasm;
-/**/
-/**/	const go = new Go;
-/**/	const imports = go.importObject;
-/**/
-/**/	__init_memory(imports);
-/**/
-/**/	if (!(module instanceof WebAssembly.Module)) module = new WebAssembly.Module(module);
-/**/
-/**/	const instance = new WebAssembly.Instance(module, imports);
-/**/
-/**/	go.run(instance);
-/**/	return __finalize_init(instance, module);
-/**/}
-/**/export default async function initAsync(input) {
-/**/	if (wasm !== undefined) return wasm;
-/**/
-/**/	if (typeof input === 'undefined') input = new URL('gofmt.wasm', import.meta.url);
-/**/
-/**/	const go = new Go;
-/**/	const imports = go.importObject;
-/**/
-/**/	if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
-/**/		input = fetch(input);
-/**/	}
-/**/
-/**/	__init_memory(imports);
-/**/
-/**/	const { instance, module } = await __load(await input, imports);
-/**/
-/**/	go.run(instance);
-/**/	return __finalize_init(instance, module);
-/**/}
-/**/export function format(input) {
-/**/	const [err, result] = wasm.format(input);
-/**/	if (err) {
-/**/		throw new Error(result);
-/**/	}
-/**/	return result;
-/**/}
-/**/
+let wasm;
+async function __load(module, imports) {
+	if (typeof Response === "function" && module instanceof Response) {
+		if (typeof WebAssembly.instantiateStreaming === "function") {
+			try {
+				return await WebAssembly.instantiateStreaming(module, imports);
+			} catch (e) {
+				if (module.headers.get("Content-Type") != "application/wasm") {
+					console.warn(
+						"`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n",
+						e,
+					);
+				} else {
+					throw e;
+				}
+			}
+		}
+		const bytes = await module.arrayBuffer();
+		return await WebAssembly.instantiate(bytes, imports);
+	} else {
+		const instance = await WebAssembly.instantiate(module, imports);
+		if (instance instanceof WebAssembly.Instance)
+			return { instance, module };
+		else return instance;
+	}
+}
+function __finalize_init(instance) {
+	return (wasm = instance);
+}
+function __init_memory(imports, maybe_memory) {}
+export function initSync(module) {
+	if (wasm !== undefined) return wasm;
+
+	const go = new Go();
+	const imports = go.importObject;
+
+	__init_memory(imports);
+
+	if (!(module instanceof WebAssembly.Module))
+		module = new WebAssembly.Module(module);
+
+	const instance = new WebAssembly.Instance(module, imports);
+
+	go.run(instance);
+	return __finalize_init(instance, module);
+}
+export default async function initAsync(input) {
+	if (wasm !== undefined) return wasm;
+
+	if (typeof input === "undefined")
+		input = new URL("gofmt.wasm", import.meta.url);
+
+	const go = new Go();
+	const imports = go.importObject;
+
+	if (
+		typeof input === "string" ||
+		(typeof Request === "function" && input instanceof Request) ||
+		(typeof URL === "function" && input instanceof URL)
+	) {
+		input = fetch(input);
+	}
+
+	__init_memory(imports);
+
+	const { instance, module } = await __load(await input, imports);
+
+	go.run(instance);
+	return __finalize_init(instance, module);
+}
+export function format(input) {
+	const [err, result] = wasm.format(input);
+	if (err) {
+		throw new Error(result);
+	}
+	return result;
+}

package/package.json

@@ -2,7 +2,7 @@
 	"name": "@wasm-fmt/gofmt",
 	"description": "A wasm based golang formatter",
 	"author": "magic-akari <akari.ccino@gamil.com>",
-	"version": "0.4.9",
+	"version": "0.5.0",
 	"license": "MIT",
 	"keywords": [
 		"wasm",
@@ -36,7 +36,7 @@
 	},
 	"scripts": {
 		"build": "./scripts/build.sh",
-		"test:node": "node --test test_node",
+		"test:node": "node --test test_node/node.test.js",
 		"test:deno": "deno test test_deno --allow-read",
 		"test:bun": "bun test test_bun"
 	},
@@ -45,5 +45,8 @@
 	},
 	"publishConfig": {
 		"access": "public"
+	},
+	"devDependencies": {
+		"@ast-grep/napi": "0.40.0"
 	}
 }