goscript 0.1.3 → 0.2.0

package/gs/os/types_js.gs.ts

@@ -2,6 +2,7 @@ import * as $ from "@goscript/builtin/index.js";
 import { ErrClosed, ErrInvalid, ErrUnimplemented } from "./error.gs.js";
 
 import * as fs from "@goscript/io/fs/index.js"
+import { FileInfoToDirEntry } from "@goscript/io/fs/readdir.js"
 import * as io from "@goscript/io/index.js"
 import * as time from "@goscript/time/index.js"
 import * as syscall from "@goscript/syscall/index.js"
@@ -219,6 +220,70 @@ export function createFileInfo(name: string, stat: HostStatLike): fs.FileInfo {
 	})
 }
 
+function joinFilePath(dir: string, name: string): string {
+	if (dir === "" || dir === ".") {
+		return name
+	}
+	return dir.replace(/\/+$/, "") + "/" + name
+}
+
+function readDirectoryInfos(name: string): [fs.FileInfo[] | null, $.GoError] {
+	const denoObj = getDeno()
+	if (denoObj?.readDirSync) {
+		try {
+			const infos: fs.FileInfo[] = []
+			for (const entry of denoObj.readDirSync(name)) {
+				infos.push(createFileInfo(entry.name, {
+					isDirectory: () => entry.isDirectory,
+					isSymbolicLink: () => entry.isSymlink,
+					mode: 0,
+					size: 0,
+				}))
+			}
+			return [infos, null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	const nodeFS = getNodeFS()
+	if (nodeFS?.readdirSync) {
+		try {
+			const infos = nodeFS.readdirSync(name, { withFileTypes: true }).map((entry: any) => {
+				const childName = String(entry.name)
+				const childPath = joinFilePath(name, childName)
+				if (nodeFS.lstatSync) {
+					try {
+						return createFileInfo(childName, nodeFS.lstatSync(childPath))
+					} catch {
+						// Fall back to Dirent metadata when the child cannot be statted.
+					}
+				}
+				return createFileInfo(childName, {
+					isDirectory: () => typeof entry.isDirectory === "function" ? entry.isDirectory() : false,
+					isSymbolicLink: () => typeof entry.isSymbolicLink === "function" ? entry.isSymbolicLink() : false,
+					mode: 0,
+					size: 0,
+				})
+			})
+			return [infos, null]
+		} catch (err) {
+			return [null, newHostError(err)]
+		}
+	}
+	return [null, ErrUnimplemented]
+}
+
+function consumeDirectoryEntries<T>(entries: T[], offset: number, n: number): [$.Slice<T>, number, $.GoError] {
+	if (n <= 0) {
+		return [$.arrayToSlice(entries.slice(offset)), entries.length, null]
+	}
+	if (offset >= entries.length) {
+		return [null, offset, io.EOF]
+	}
+	const next = Math.min(entries.length, offset + n)
+	return [$.arrayToSlice(entries.slice(offset, next)), next, null]
+}
+
 export function createHostFile(name: string, fd: number = -1, handle: DenoFileLike | null = null): File {
 	return new File({
 		fd,
@@ -260,6 +325,10 @@ export class File {
 	public name: string
 	public closed: boolean
 	public fd: number
+	public dirEntryOffset: number
+	public dirInfoOffset: number
+	public cachedDirEntries: fs.DirEntry[] | null
+	public cachedDirInfos: fs.FileInfo[] | null
 
 	public _fields: {
 		file: $.VarRef<file | null>;
@@ -269,6 +338,10 @@ export class File {
 		this.name = init?.name ?? ""
 		this.closed = init?.closed ?? false
 		this.fd = init?.fd ?? -1
+		this.dirEntryOffset = 0
+		this.dirInfoOffset = 0
+		this.cachedDirEntries = null
+		this.cachedDirInfos = null
 		this._fields = {
 			file: $.varRef(init?.file ?? null)
 		}
@@ -284,19 +357,58 @@ export class File {
 	}
 
 	public Readdir(n: number): [$.Slice<fs.FileInfo>, $.GoError] {
-		return [null, ErrUnimplemented]
+		if (this.closed) {
+			return [null, ErrClosed]
+		}
+		if (this.cachedDirInfos === null) {
+			const [infos, err] = readDirectoryInfos(this.name)
+			if (err !== null) {
+				return [null, err]
+			}
+			this.cachedDirInfos = infos ?? []
+			this.dirInfoOffset = 0
+		}
+		const [out, next, err] = consumeDirectoryEntries(this.cachedDirInfos, this.dirInfoOffset, n)
+		this.dirInfoOffset = next
+		return [out, err]
 	}
 
 	public Readdirnames(n: number): [$.Slice<string>, $.GoError] {
-		return [null, ErrUnimplemented]
+		const [infos, err] = this.Readdir(n)
+		if (err !== null) {
+			return [null, err]
+		}
+		return [$.arrayToSlice((infos ?? []).map((info) => info!.Name())), null]
 	}
 
 	public ReadDir(n: number): [$.Slice<fs.DirEntry>, $.GoError] {
-		return [null, ErrUnimplemented]
+		if (this.closed) {
+			return [null, ErrClosed]
+		}
+		if (this.cachedDirEntries === null) {
+			const [infos, err] = readDirectoryInfos(this.name)
+			if (err !== null) {
+				return [null, err]
+			}
+			this.cachedDirEntries = (infos ?? []).map((info) => FileInfoToDirEntry(info)).filter((entry): entry is fs.DirEntry => entry !== null)
+			this.dirEntryOffset = 0
+		}
+		const [out, next, err] = consumeDirectoryEntries(this.cachedDirEntries, this.dirEntryOffset, n)
+		this.dirEntryOffset = next
+		return [out, err]
 	}
 
 	public readdir(n: number, mode: readdirMode): [$.Slice<string>, $.Slice<fs.DirEntry>, $.Slice<fs.FileInfo>, $.GoError] {
-		return [null, null, null, ErrUnimplemented]
+		if (mode === readdirName) {
+			const [names, err] = this.Readdirnames(n)
+			return [names, null, null, err]
+		}
+		if (mode === readdirDirEntry) {
+			const [entries, err] = this.ReadDir(n)
+			return [null, entries, null, err]
+		}
+		const [infos, err] = this.Readdir(n)
+		return [null, null, infos, err]
 	}
 
 	public Name(): string {
@@ -366,11 +478,34 @@ export class File {
 		return [0, ErrUnimplemented]
 	}
 
-	public ReadFrom(r: io.Reader): [number, $.GoError] {
+	public async ReadFrom(r: io.Reader): Promise<[number, $.GoError]> {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(this, r) as any
+		const buf = $.makeSlice<number>(32 * 1024, undefined, "byte")
+		let written = 0
+		while (true) {
+			const [nr, er] = await (r.Read(buf) as any)
+			if (nr > 0) {
+				const [nw, ew] = this.Write($.goSlice(buf, 0, nr))
+				if (nw < 0 || nr < nw) {
+					return [written, ew ?? io.ErrShortWrite]
+				}
+				written += nw
+				if (ew !== null) {
+					return [written, ew]
+				}
+				if (nr !== nw) {
+					return [written, io.ErrShortWrite]
+				}
+			}
+			if (er !== null) {
+				if (er === io.EOF) {
+					return [written, null]
+				}
+				return [written, er]
+			}
+		}
 	}
 
 	public Write(b: $.Bytes): [number, $.GoError] {
@@ -424,11 +559,34 @@ export class File {
 		return [0, ErrUnimplemented]
 	}
 
-	public WriteTo(w: io.Writer): [number, $.GoError] {
+	public async WriteTo(w: io.Writer): Promise<[number, $.GoError]> {
 		if (this.closed) {
 			return [0, ErrClosed]
 		}
-		return io.Copy(w, this) as any
+		const buf = $.makeSlice<number>(32 * 1024, undefined, "byte")
+		let written = 0
+		while (true) {
+			const [nr, er] = this.Read(buf)
+			if (nr > 0) {
+				const [nw, ew] = await (w.Write($.goSlice(buf, 0, nr)) as any)
+				if (nw < 0 || nr < nw) {
+					return [written, ew ?? io.ErrShortWrite]
+				}
+				written += nw
+				if (ew !== null) {
+					return [written, ew]
+				}
+				if (nr !== nw) {
+					return [written, io.ErrShortWrite]
+				}
+			}
+			if (er !== null) {
+				if (er === io.EOF) {
+					return [written, null]
+				}
+				return [written, er]
+			}
+		}
 	}
 
 	public Seek(offset: number, whence: number): [number, $.GoError] {
@@ -665,7 +823,7 @@ export class File {
 			{ name: "Close", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }
 		],
 		File,
-		{ "file": { kind: $.TypeKind.Pointer, elemType: "file" }, "name": { kind: $.TypeKind.Basic, name: "string" }, "closed": { kind: $.TypeKind.Basic, name: "boolean" }, "fd": { kind: $.TypeKind.Basic, name: "number" } }
+		[{ name: "file", key: "file", type: { kind: $.TypeKind.Pointer, elemType: "file" } }, { name: "name", key: "name", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "closed", key: "closed", type: { kind: $.TypeKind.Basic, name: "boolean" } }, { name: "fd", key: "fd", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }
 
@@ -681,6 +839,9 @@ class file {
 
 // readdirMode mirrors the Go runtime helper enum.
 type readdirMode = number
+const readdirName: readdirMode = 0
+const readdirDirEntry: readdirMode = 1
+const readdirFileInfo: readdirMode = 2
 
 // File mode constants
 export let ModeDir: fs.FileMode = fs.ModeDir

package/gs/os/types_unix.gs.ts

@@ -108,7 +108,7 @@ class fileStat {
 	  new fileStat(),
 	  [{ name: "Name", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "IsDir", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Size", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Mode", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "ModTime", args: [], returns: [{ type: "Time" }] }, { name: "Sys", args: [], returns: [{ type: { kind: $.TypeKind.Interface, methods: [] } }] }],
 	  fileStat,
-	  {"name": { kind: $.TypeKind.Basic, name: "string" }, "size": { kind: $.TypeKind.Basic, name: "number" }, "mode": { kind: $.TypeKind.Basic, name: "number" }, "modTime": "Time", "sys": "Stat_t"}
+	  [{ name: "name", key: "name", type: { kind: $.TypeKind.Basic, name: "string" } }, { name: "size", key: "size", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "mode", key: "mode", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "modTime", key: "modTime", type: "Time" }, { name: "sys", key: "sys", type: "Stat_t" }]
 	);
 }
 

package/gs/path/path.ts

@@ -112,14 +112,18 @@ class lazybuf {
       },
     ],
     lazybuf,
-    {
-      s: { kind: $.TypeKind.Basic, name: 'string' },
-      buf: {
-        kind: $.TypeKind.Slice,
-        elemType: { kind: $.TypeKind.Basic, name: 'number' },
+    [
+      { name: 's', key: 's', type: { kind: $.TypeKind.Basic, name: 'string' } },
+      {
+        name: 'buf',
+        key: 'buf',
+        type: {
+          kind: $.TypeKind.Slice,
+          elemType: { kind: $.TypeKind.Basic, name: 'number' },
+        },
       },
-      w: { kind: $.TypeKind.Basic, name: 'number' },
-    },
+      { name: 'w', key: 'w', type: { kind: $.TypeKind.Basic, name: 'number' } },
+    ],
   )
 }
 

package/gs/reflect/deepequal.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest'
 import { DeepEqual } from './deepequal.js'
-import { Value, BasicType, Int, String as StringType } from './type.js'
+import { Value, BasicType, Int, String as StringType, Uint32 } from './type.js'
 
 describe('DeepEqual', () => {
   it('should compare primitive values correctly', () => {
@@ -38,4 +38,13 @@ describe('DeepEqual', () => {
     expect(DeepEqual(v1, v2)).toBe(true)
     expect(DeepEqual(v1, v3)).toBe(false)
   })
+
+  it('reads numeric boxed values with basic numeric kinds', () => {
+    const v = new Value(
+      { sentinel: true, valueOf: () => 7 } as any,
+      new BasicType(Uint32, 'uint32'),
+    )
+
+    expect(v.Uint()).toBe(7)
+  })
 })

package/gs/reflect/field.test.ts

@@ -4,6 +4,7 @@ import {
   TypeKind,
   arrayToSlice,
   asArray,
+  isOwnedPointerHandle,
   registerStructType,
 } from '../builtin/index.js'
 import { NewAt, TypeOf, ValueOf } from './index.js'
@@ -16,34 +17,48 @@ class Person {
     return this.Name
   }
 }
-;(Person as any).__typeInfo = { name: 'main.Person' }
 
 describe('reflect struct field access', () => {
-  it('finds struct fields by name and index', () => {
-    registerStructType(
+  it('finds struct fields by name and index', async () => {
+    ;(Person as any).__typeInfo = registerStructType(
       'main.Person',
       new Person(),
-      [{ name: 'String', args: [], returns: [] }],
+      [
+        {
+          name: 'String',
+          args: [],
+          returns: [{ type: { kind: TypeKind.Basic, name: 'string' } }],
+        },
+      ],
       Person,
-      {
-        Name: 'string',
-        Count: { kind: TypeKind.Basic, name: 'int' },
-      },
+      [
+        { name: 'FullName', key: 'Name', type: 'string' },
+        {
+          name: 'Count',
+          key: 'Count',
+          type: { kind: TypeKind.Basic, name: 'int' },
+        },
+      ],
     )
 
     const person = new Person()
     const typ = TypeOf(person)
-    const [field, ok] = typ.FieldByName('Name')
+    const [field, ok] = typ.FieldByName('FullName')
 
     expect(ok).toBe(true)
-    expect(field.Name).toBe('Name')
+    expect(field.Name).toBe('FullName')
     expect(field.Index).toEqual([0])
     expect(typ.FieldByNameFunc((name) => name === 'Count')[0].Name).toBe(
       'Count',
     )
     expect(typ.AssignableTo(typ)).toBe(true)
-    expect(typ.MethodByName('String')[1]).toBe(true)
-    expect(ValueOf(person).FieldByName('Name').String()).toBe('Ada')
+    const [method, methodOK] = typ.MethodByName('String')
+    expect(methodOK).toBe(true)
+    expect(method.Type.NumIn()).toBe(1)
+    expect(method.Type.In(0).String()).toBe('main.Person')
+    expect(method.Type.NumOut()).toBe(1)
+    expect(method.Type.Out(0).String()).toBe('string')
+    expect(ValueOf(person).FieldByName('FullName').String()).toBe('Ada')
     expect(
       ValueOf(person)
         .FieldByIndex(arrayToSlice([1]))
@@ -53,10 +68,17 @@ describe('reflect struct field access', () => {
 
     const stringMethod = ValueOf(person).MethodByName('String')
     expect(stringMethod.IsValid()).toBe(true)
-    expect(asArray(stringMethod.Call(arrayToSlice([])))[0].String()).toBe('Ada')
+    expect(stringMethod.Type().NumIn()).toBe(0)
+    expect(stringMethod.Type().NumOut()).toBe(1)
+    expect(stringMethod.Type().Out(0).String()).toBe('string')
+    expect(asArray(await stringMethod.Call(arrayToSlice([])))[0].String()).toBe(
+      'Ada',
+    )
 
-    const nameField = ValueOf(person).FieldByName('Name')
-    const namePtr = NewAt(nameField.Type(), nameField.UnsafeAddr() as any)
+    const nameField = ValueOf(person).FieldByName('FullName')
+    const nameAddress = nameField.UnsafeAddr()
+    expect(isOwnedPointerHandle(nameAddress)).toBe(true)
+    const namePtr = NewAt(nameField.Type(), nameAddress as any)
     namePtr.Elem().SetString('Grace')
     expect(person.Name).toBe('Grace')
   })