goscript 0.1.3 → 0.1.4

package/gs/os/readdir.test.ts

@@ -0,0 +1,56 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { afterEach, describe, expect, it } from 'vitest'
+
+import * as io from '@goscript/io/index.js'
+
+import { Open } from './file_js.gs.js'
+
+const tempRoots: string[] = []
+
+afterEach(() => {
+  for (const root of tempRoots.splice(0)) {
+    rmSync(root, { force: true, recursive: true })
+  }
+})
+
+function makeTempRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), 'goscript-os-readdir-'))
+  tempRoots.push(root)
+  return root
+}
+
+describe('os file directory reads', () => {
+  it('reads host directory entries through os.File', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+    writeFileSync(join(root, 'b.txt'), 'b')
+
+    const [dir, openErr] = Open(root)
+    expect(openErr).toBeNull()
+    expect(dir).not.toBeNull()
+    const [entries, readErr] = dir!.ReadDir(-1)
+    expect(readErr).toBeNull()
+    expect(entries?.map((entry) => entry!.Name()).sort()).toEqual([
+      'a.txt',
+      'b.txt',
+    ])
+    expect(dir!.Close()).toBeNull()
+  })
+
+  it('returns EOF after positive-count directory reads are exhausted', () => {
+    const root = makeTempRoot()
+    writeFileSync(join(root, 'a.txt'), 'a')
+
+    const [dir] = Open(root)
+    const [first, firstErr] = dir!.Readdirnames(1)
+    expect(firstErr).toBeNull()
+    expect(first).toHaveLength(1)
+
+    const [second, secondErr] = dir!.Readdirnames(1)
+    expect(second).toBeNull()
+    expect(secondErr).toBe(io.EOF)
+    expect(dir!.Close()).toBeNull()
+  })
+})

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] {
@@ -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/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/type.ts

@@ -401,8 +401,9 @@ export class Value {
 
   // Methods required by godoc.txt and used throughout the codebase
   public Int(): number {
-    if (typeof this._value === 'number' && Number.isInteger(this._value)) {
-      return this._value
+    const value = this.numericValue()
+    if (value !== null && Number.isInteger(value)) {
+      return value
     }
     throw new Error(
       'reflect: call of reflect.Value.Int on ' +
@@ -412,8 +413,9 @@ export class Value {
   }
 
   public Uint(): number {
-    if (typeof this._value === 'number' && this._value >= 0) {
-      return this._value
+    const value = this.numericValue()
+    if (value !== null && value >= 0) {
+      return value
     }
     throw new Error(
       'reflect: call of reflect.Value.Uint on ' +
@@ -423,8 +425,9 @@ export class Value {
   }
 
   public Float(): number {
-    if (typeof this._value === 'number') {
-      return this._value
+    const value = this.numericValue()
+    if (value !== null) {
+      return value
     }
     throw new Error(
       'reflect: call of reflect.Value.Float on ' +
@@ -444,6 +447,23 @@ export class Value {
     )
   }
 
+  private numericValue(): number | null {
+    if (typeof this._value === 'number') {
+      return this._value
+    }
+    if (
+      this._value !== null &&
+      typeof this._value === 'object' &&
+      typeof (this._value as { valueOf?: unknown }).valueOf === 'function'
+    ) {
+      const value = (this._value as { valueOf(): unknown }).valueOf()
+      if (typeof value === 'number') {
+        return value
+      }
+    }
+    return null
+  }
+
   public String(): string {
     if (typeof this._value === 'string') {
       return this._value
@@ -576,6 +596,17 @@ export class Value {
       const elemType = this._type.Elem()
       return new Value(varRef.value, elemType, varRef)
     }
+    if (
+      this._type.Kind() === Ptr &&
+      this._value &&
+      typeof this._value === 'object' &&
+      '__goValue' in this._value &&
+      $.isVarRef((this._value as { __goValue: unknown }).__goValue)
+    ) {
+      const varRef = (this._value as { __goValue: $.VarRef<ReflectValue> })
+        .__goValue
+      return new Value(varRef.value, this._type.Elem(), varRef)
+    }
     // For interfaces, return the underlying value
     return new Value(this._value, this._type, this._parentVarRef)
   }
@@ -2172,62 +2203,14 @@ class StructType implements Type {
 
   static createTypeFromFieldInfo(ti: any): Type {
     if (typeof ti === 'string') {
-      switch (ti) {
-        case 'string':
-          return new BasicType(String, ti, 16)
-        case 'int':
-        case 'int32':
-        case 'int64':
-        case 'number':
-          return new BasicType(Int, ti === 'number' ? 'int' : ti, 8)
-        case 'bool':
-        case 'boolean':
-          return new BasicType(Bool, 'bool', 1)
-        case 'float64':
-          return new BasicType(Float64, ti, 8)
-        case 'complex64':
-          return new BasicType(Complex64, ti, 8)
-        case 'complex128':
-          return new BasicType(Complex128, ti, 16)
-        case 'uint':
-        case 'uint32':
-        case 'uint64':
-          return new BasicType(Uint, ti, 8)
-        default:
-          return new BasicType(Invalid, ti, 8)
-      }
+      return basicTypeFromName(ti === 'number' ? 'int' : ti)
     } else if (ti && ti.kind) {
       // Handle TypeInfo objects from the builtin type system
       const name = ti.name || 'unknown'
       const typeName = ti.typeName || ''
       switch (ti.kind) {
         case 'basic':
-          // Map TypeScript type names to Go type names
-          switch (name) {
-            case 'string':
-              return new BasicType(String, 'string', 16, typeName)
-            case 'number':
-            case 'int':
-            case 'int32':
-            case 'int64':
-              return new BasicType(
-                Int,
-                name === 'number' ? 'int' : name,
-                8,
-                typeName,
-              )
-            case 'boolean':
-            case 'bool':
-              return new BasicType(Bool, 'bool', 1, typeName)
-            case 'float64':
-              return new BasicType(Float64, 'float64', 8, typeName)
-            case 'complex64':
-              return new BasicType(Complex64, 'complex64', 8, typeName)
-            case 'complex128':
-              return new BasicType(Complex128, 'complex128', 16, typeName)
-            default:
-              return new BasicType(Invalid, name, 8, typeName)
-          }
+          return basicTypeFromName(name === 'number' ? 'int' : name, typeName)
         case 'slice':
           if (ti.elemType) {
             return new SliceType(
@@ -2254,6 +2237,49 @@ class StructType implements Type {
   }
 }
 
+function basicTypeFromName(name: string, typeName = ''): BasicType {
+  switch (name) {
+    case 'string':
+      return new BasicType(String, 'string', 16, typeName)
+    case 'bool':
+    case 'boolean':
+      return new BasicType(Bool, 'bool', 1, typeName)
+    case 'int':
+      return new BasicType(Int, 'int', 8, typeName)
+    case 'int8':
+      return new BasicType(Int8, 'int8', 1, typeName)
+    case 'int16':
+      return new BasicType(Int16, 'int16', 2, typeName)
+    case 'int32':
+      return new BasicType(Int32, 'int32', 4, typeName)
+    case 'int64':
+      return new BasicType(Int64, 'int64', 8, typeName)
+    case 'uint':
+      return new BasicType(Uint, 'uint', 8, typeName)
+    case 'uint8':
+    case 'byte':
+      return new BasicType(Uint8, name, 1, typeName)
+    case 'uint16':
+      return new BasicType(Uint16, 'uint16', 2, typeName)
+    case 'uint32':
+      return new BasicType(Uint32, 'uint32', 4, typeName)
+    case 'uint64':
+      return new BasicType(Uint64, 'uint64', 8, typeName)
+    case 'uintptr':
+      return new BasicType(Uintptr, 'uintptr', 8, typeName)
+    case 'float32':
+      return new BasicType(Float32, 'float32', 4, typeName)
+    case 'float64':
+      return new BasicType(Float64, 'float64', 8, typeName)
+    case 'complex64':
+      return new BasicType(Complex64, 'complex64', 8, typeName)
+    case 'complex128':
+      return new BasicType(Complex128, 'complex128', 16, typeName)
+    default:
+      return new BasicType(Invalid, name, 8, typeName)
+  }
+}
+
 function structFieldsFromTypeInfo(
   ti: $.StructTypeInfo,
 ): Array<{ name: string; type: Type; tag?: string }> {
@@ -2614,6 +2640,15 @@ function getTypeOf(value: ReflectValue): Type {
         return new PointerType(elemType)
       }
 
+      if (
+        '__goTypeInfo' in value &&
+        (value as { __goTypeInfo?: $.TypeInfo | string }).__goTypeInfo
+      ) {
+        return typeFromTypeInfo(
+          (value as { __goTypeInfo: $.TypeInfo | string }).__goTypeInfo,
+        )
+      }
+
       if (
         'real' in value &&
         'imag' in value &&

package/gs/reflect/typefor.test.ts

@@ -3,12 +3,14 @@ import {
   makeMap,
   mapGet,
   mapSet,
+  namedValueInterfaceValue,
   TypeKind,
   registerInterfaceType,
   registerStructType,
+  varRef,
 } from '../builtin/index.js'
 import { StructField } from './types.js'
-import { Int, Struct, TypeFor } from './type.js'
+import { Int, Ptr, Struct, TypeFor, TypeOf, Uint64, ValueOf } from './type.js'
 
 describe('TypeFor', () => {
   it('exposes StructField PkgPath and exported semantics', () => {
@@ -48,6 +50,34 @@ describe('TypeFor', () => {
     expect(namedIntType.Kind()).toBe(Int)
   })
 
+  it('preserves named pointer type metadata on interface boxes', () => {
+    const target = varRef(0)
+    const boxed = namedValueInterfaceValue(
+      target,
+      '*chunker.Pol',
+      {},
+      {
+        kind: TypeKind.Pointer,
+        elemType: {
+          kind: TypeKind.Basic,
+          name: 'uint64',
+          typeName: 'chunker.Pol',
+        },
+      },
+    )
+
+    const typ = TypeOf(boxed)
+    expect(typ.String()).toBe('*chunker.Pol')
+    expect(typ.Kind()).toBe(Ptr)
+    expect(typ.Elem().Kind()).toBe(Uint64)
+    expect(typ.Elem().Name()).toBe('Pol')
+
+    const elem = ValueOf(boxed).Elem()
+    expect(elem.Kind()).toBe(Uint64)
+    elem.SetUint(15)
+    expect(target.value).toBe(15)
+  })
+
   it('formats literal interface methods from type metadata', () => {
     const ifaceType = TypeFor({
       T: {

package/gs/strings/meta.json

@@ -5,5 +5,8 @@
     "iter",
     "unicode",
     "unicode/utf8"
-  ]
-} 
+  ],
+  "asyncMethods": {
+    "Reader.WriteTo": true
+  }
+}

package/gs/strings/reader.test.ts

@@ -165,7 +165,7 @@ describe('strings/Reader', () => {
       expect(err).not.toBeNull()
     })
 
-    it('should write to writer', () => {
+    it('should write to writer', async () => {
       const r = new Reader({ s: 'hello world' })
       r.ReadByte() // advance position
 
@@ -177,7 +177,7 @@ describe('strings/Reader', () => {
         },
       }
 
-      const [n, err] = r.WriteTo(writer)
+      const [n, err] = await r.WriteTo(writer)
       expect(n).toBe(10) // remaining bytes
       expect(err).toBeNull()
       expect(r.Len()).toBe(0)

package/gs/strings/reader.ts

@@ -188,7 +188,7 @@ export class Reader {
   }
 
   // WriteTo implements the [io.WriterTo] interface.
-  public WriteTo(w: io.Writer): [number, $.GoError] {
+  public async WriteTo(w: io.Writer): Promise<[number, $.GoError]> {
     const r = this
     r!.prevRune = -1
     if (r!.i >= ($.len(r!.s) as number)) {
@@ -197,7 +197,7 @@ export class Reader {
     let s = $.sliceString(r!.s, r!.i, undefined)
     let m: number
     let err: $.GoError
-    ;[m, err] = io.WriteString(w, s)
+    ;[m, err] = await io.WriteString(w, s)
     if (m > $.len(s)) {
       $.panic('strings.Reader.WriteTo: invalid WriteString count')
     }

package/gs/sync/meta.json

@@ -10,6 +10,7 @@
     "WaitGroup.Wait": true,
     "Once.Do": true,
     "Cond.Wait": true,
+    "Pool.Get": true,
     "Map.CompareAndDelete": true,
     "Map.Delete": true,
     "Map.Load": true,

package/gs/sync/sync.test.ts

@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest'
 
-import { Cond, Map, Mutex, RWMutex, WaitGroup } from './sync.js'
+import * as $ from '@goscript/builtin/index.js'
+
+import { Cond, Map, Mutex, Pool, RWMutex, WaitGroup } from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -89,4 +91,42 @@ describe('sync.Map', () => {
 
     expect(visited).toEqual(['a:1'])
   })
+
+  it('matches boxed comparable interface keys', async () => {
+    const m = new Map()
+    const first = $.namedValueInterfaceValue(8, 'uint16', {}, {
+      kind: $.TypeKind.Basic,
+      name: 'uint16',
+    })
+    const second = $.namedValueInterfaceValue(8, 'uint16', {}, {
+      kind: $.TypeKind.Basic,
+      name: 'uint16',
+    })
+
+    await m.Store(first, 'compressor')
+    expect(await m.Load(second)).toEqual(['compressor', true])
+    expect(await m.LoadOrStore(second, 'duplicate')).toEqual([
+      'compressor',
+      true,
+    ])
+    expect(await m.CompareAndSwap(second, 'compressor', 'updated')).toBe(true)
+    expect(await m.Load(first)).toEqual(['updated', true])
+    expect(await m.CompareAndDelete(first, 'updated')).toBe(true)
+    expect(await m.Load(second)).toEqual([undefined, false])
+  })
+})
+
+describe('sync.Pool', () => {
+  it('awaits async New functions before returning a pooled value', async () => {
+    const pool = new Pool({
+      New: async () => {
+        await Promise.resolve()
+        return 'created'
+      },
+    })
+
+    expect(await pool.Get()).toBe('created')
+    pool.Put('reused')
+    expect(await pool.Get()).toBe('reused')
+  })
 })