goscript 0.1.0 → 0.1.2

package/gs/internal/byteorder/index.ts

@@ -1,28 +1,30 @@
 import * as $ from '@goscript/builtin/index.js'
 
-// Stub implementations for internal/byteorder package
 export function LittleEndian(): boolean {
-  return true // Assume little endian for JS
+  return true
 }
 
-// Big Endian byte order functions
 export function BEUint16(b: $.Bytes): number {
   return (b![0] << 8) | b![1]
 }
 
 export function BEUint32(b: $.Bytes): number {
-  return (b![0] << 24) | (b![1] << 16) | (b![2] << 8) | b![3]
+  return (((b![0] << 24) >>> 0) | (b![1] << 16) | (b![2] << 8) | b![3]) >>> 0
 }
 
 export function BEUint64(b: $.Bytes): number {
-  // JavaScript numbers are 64-bit floats, so we'll lose precision for very large integers
-  // For our stub purposes, this should be sufficient
-  let high = BEUint32(b)
-  let low = BEUint32($.goSlice(b, 4, undefined))
-  return high * 0x100000000 + low
+  return Number(
+    (BigInt(b![0]) << 56n) |
+      (BigInt(b![1]) << 48n) |
+      (BigInt(b![2]) << 40n) |
+      (BigInt(b![3]) << 32n) |
+      (BigInt(b![4]) << 24n) |
+      (BigInt(b![5]) << 16n) |
+      (BigInt(b![6]) << 8n) |
+      BigInt(b![7]),
+  )
 }
 
-// Little Endian byte order functions
 export function LEUint16(b: $.Bytes): number {
   return b![0] | (b![1] << 8)
 }
@@ -32,14 +34,18 @@ export function LEUint32(b: $.Bytes): number {
 }
 
 export function LEUint64(b: $.Bytes): number {
-  // JavaScript numbers are 64-bit floats, so we'll lose precision for very large integers
-  // For our stub purposes, this should be sufficient
-  let low = LEUint32(b)
-  let high = LEUint32($.goSlice(b, 4, undefined))
-  return low + high * 0x100000000
+  return Number(
+    BigInt(b![0]) |
+      (BigInt(b![1]) << 8n) |
+      (BigInt(b![2]) << 16n) |
+      (BigInt(b![3]) << 24n) |
+      (BigInt(b![4]) << 32n) |
+      (BigInt(b![5]) << 40n) |
+      (BigInt(b![6]) << 48n) |
+      (BigInt(b![7]) << 56n),
+  )
 }
 
-// Big Endian Put functions
 export function BEPutUint16(b: $.Bytes, v: number): void {
   b![0] = (v >> 8) & 0xff
   b![1] = v & 0xff
@@ -52,14 +58,18 @@ export function BEPutUint32(b: $.Bytes, v: number): void {
   b![3] = v & 0xff
 }
 
-export function BEPutUint64(b: $.Bytes, v: number): void {
-  const high = Math.floor(v / 0x100000000)
-  const low = v >>> 0
-  BEPutUint32(b, high)
-  BEPutUint32($.goSlice(b, 4, undefined), low)
+export function BEPutUint64(b: $.Bytes, v: bigint | number): void {
+  const x = BigInt(v) & ((1n << 64n) - 1n)
+  b![0] = Number((x >> 56n) & 0xffn)
+  b![1] = Number((x >> 48n) & 0xffn)
+  b![2] = Number((x >> 40n) & 0xffn)
+  b![3] = Number((x >> 32n) & 0xffn)
+  b![4] = Number((x >> 24n) & 0xffn)
+  b![5] = Number((x >> 16n) & 0xffn)
+  b![6] = Number((x >> 8n) & 0xffn)
+  b![7] = Number(x & 0xffn)
 }
 
-// Little Endian Put functions
 export function LEPutUint16(b: $.Bytes, v: number): void {
   b![0] = v & 0xff
   b![1] = (v >> 8) & 0xff
@@ -72,9 +82,72 @@ export function LEPutUint32(b: $.Bytes, v: number): void {
   b![3] = (v >> 24) & 0xff
 }
 
-export function LEPutUint64(b: $.Bytes, v: number): void {
-  const low = v >>> 0
-  const high = Math.floor(v / 0x100000000)
-  LEPutUint32(b, low)
-  LEPutUint32($.goSlice(b, 4, undefined), high)
+export function LEPutUint64(b: $.Bytes, v: bigint | number): void {
+  const x = BigInt(v) & ((1n << 64n) - 1n)
+  b![0] = Number(x & 0xffn)
+  b![1] = Number((x >> 8n) & 0xffn)
+  b![2] = Number((x >> 16n) & 0xffn)
+  b![3] = Number((x >> 24n) & 0xffn)
+  b![4] = Number((x >> 32n) & 0xffn)
+  b![5] = Number((x >> 40n) & 0xffn)
+  b![6] = Number((x >> 48n) & 0xffn)
+  b![7] = Number((x >> 56n) & 0xffn)
+}
+
+export function BEAppendUint16(b: $.Bytes | null, v: number): $.Bytes {
+  return $.append(b, (v >> 8) & 0xff, v & 0xff) as $.Bytes
+}
+
+export function BEAppendUint32(b: $.Bytes | null, v: number): $.Bytes {
+  return $.append(
+    b,
+    (v >> 24) & 0xff,
+    (v >> 16) & 0xff,
+    (v >> 8) & 0xff,
+    v & 0xff,
+  ) as $.Bytes
+}
+
+export function BEAppendUint64(b: $.Bytes | null, v: bigint | number): $.Bytes {
+  const x = BigInt(v) & ((1n << 64n) - 1n)
+  return $.append(
+    b,
+    Number((x >> 56n) & 0xffn),
+    Number((x >> 48n) & 0xffn),
+    Number((x >> 40n) & 0xffn),
+    Number((x >> 32n) & 0xffn),
+    Number((x >> 24n) & 0xffn),
+    Number((x >> 16n) & 0xffn),
+    Number((x >> 8n) & 0xffn),
+    Number(x & 0xffn),
+  ) as $.Bytes
+}
+
+export function LEAppendUint16(b: $.Bytes | null, v: number): $.Bytes {
+  return $.append(b, v & 0xff, (v >> 8) & 0xff) as $.Bytes
+}
+
+export function LEAppendUint32(b: $.Bytes | null, v: number): $.Bytes {
+  return $.append(
+    b,
+    v & 0xff,
+    (v >> 8) & 0xff,
+    (v >> 16) & 0xff,
+    (v >> 24) & 0xff,
+  ) as $.Bytes
+}
+
+export function LEAppendUint64(b: $.Bytes | null, v: bigint | number): $.Bytes {
+  const x = BigInt(v) & ((1n << 64n) - 1n)
+  return $.append(
+    b,
+    Number(x & 0xffn),
+    Number((x >> 8n) & 0xffn),
+    Number((x >> 16n) & 0xffn),
+    Number((x >> 24n) & 0xffn),
+    Number((x >> 32n) & 0xffn),
+    Number((x >> 40n) & 0xffn),
+    Number((x >> 48n) & 0xffn),
+    Number((x >> 56n) & 0xffn),
+  ) as $.Bytes
 }

package/gs/internal/godebug/index.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest'
+
+import { New, Setting, Value } from './index.js'
+
+describe('internal/godebug override', () => {
+  it('returns stable setting values', () => {
+    const setting = New('#fips140')
+
+    expect(setting).toBeInstanceOf(Setting)
+    expect(setting.Name()).toBe('fips140')
+    expect(setting.Undocumented()).toBe(true)
+    expect(setting.Value()).toBe('')
+    expect(setting.String()).toBe('fips140=')
+    expect(Value('fips140')).toBe('')
+  })
+})

package/gs/internal/godebug/index.ts

@@ -0,0 +1,35 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export class Setting {
+  constructor(public name = '') {}
+
+  public IncNonDefault(): void {}
+
+  public Name(): string {
+    return this.name.startsWith('#') ? this.name.slice(1) : this.name
+  }
+
+  public String(): string {
+    return `${this.Name()}=${this.Value()}`
+  }
+
+  public Undocumented(): boolean {
+    return this.name.startsWith('#')
+  }
+
+  public Value(): string {
+    return ''
+  }
+
+  public clone(): Setting {
+    return new Setting(this.name)
+  }
+}
+
+export function New(name: string): Setting {
+  return $.markAsStructValue(new Setting(name))
+}
+
+export function Value(name: string): string {
+  return New(name).Value()
+}

package/gs/io/fs/index.ts

@@ -3,6 +3,7 @@ export * from './fs.js'
 export * from './glob.js'
 export * from './readdir.js'
 export * from './readfile.js'
+export * from './readlink.js'
 export * from './stat.js'
 export * from './sub.js'
 export * from './walk.js'

package/gs/io/fs/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncFunctions": {
+    "WalkDir": true
+  }
+}

package/gs/io/fs/readlink.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+
+import type { File, FileInfo } from './fs.js'
+import { ErrInvalid } from './fs.js'
+import { Lstat, ReadLink } from './readlink.js'
+
+class linkFS {
+  Open(_name: string): [File, Error | null] {
+    return [null, ErrInvalid]
+  }
+
+  ReadLink(_name: string): [string, Error | null] {
+    return ['target.txt', null]
+  }
+
+  Lstat(_name: string): [FileInfo, Error | null] {
+    return [null, ErrInvalid]
+  }
+}
+
+class basicFS {
+  Open(_name: string): [File, Error | null] {
+    return [null, ErrInvalid]
+  }
+}
+
+describe('io/fs ReadLink', () => {
+  it('delegates to ReadLinkFS implementations', () => {
+    expect(ReadLink(new linkFS(), 'link')).toEqual(['target.txt', null])
+  })
+
+  it('returns readlink PathError when unsupported', () => {
+    const [, err] = ReadLink(new basicFS(), 'link')
+
+    expect(err?.Error()).toBe('readlink link: invalid argument')
+  })
+
+  it('uses Lstat from ReadLinkFS implementations', () => {
+    const [, err] = Lstat(new linkFS(), 'link')
+
+    expect(err).toBe(ErrInvalid)
+  })
+})

package/gs/io/fs/readlink.ts

@@ -0,0 +1,69 @@
+import * as $ from '@goscript/builtin/index.js'
+import { ErrInvalid, FileInfo, FS, PathError } from './fs.js'
+import { Stat } from './stat.js'
+
+export type ReadLinkFS =
+  | null
+  | ({
+      ReadLink(name: string): [string, $.GoError]
+      Lstat(name: string): [FileInfo, $.GoError]
+    } & FS)
+
+$.registerInterfaceType('ReadLinkFS', null, [
+  {
+    name: 'ReadLink',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: { kind: $.TypeKind.Basic, name: 'string' } },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
+      },
+    ],
+  },
+  {
+    name: 'Lstat',
+    args: [{ name: 'name', type: { kind: $.TypeKind.Basic, name: 'string' } }],
+    returns: [
+      { type: 'FileInfo' },
+      {
+        type: {
+          kind: $.TypeKind.Interface,
+          name: 'GoError',
+          methods: [
+            {
+              name: 'Error',
+              args: [],
+              returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }],
+            },
+          ],
+        },
+      },
+    ],
+  },
+])
+
+export function ReadLink(fsys: FS, name: string): [string, $.GoError] {
+  const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')
+  if (!ok) {
+    return ['', new PathError({ Err: ErrInvalid, Op: 'readlink', Path: name })]
+  }
+  return sym!.ReadLink(name)
+}
+
+export function Lstat(fsys: FS, name: string): [FileInfo, $.GoError] {
+  const { value: sym, ok } = $.typeAssert<ReadLinkFS>(fsys, 'ReadLinkFS')
+  if (!ok) {
+    return Stat(fsys, name)
+  }
+  return sym!.Lstat(name)
+}

package/gs/io/fs/walk.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from 'vitest'
+
+import type { File, FileInfo } from './fs.js'
+import { ModeDir } from './fs.js'
+import { WalkDir } from './walk.js'
+
+class info implements FileInfo {
+  constructor(
+    private name: string,
+    private dir: boolean,
+  ) {}
+
+  IsDir(): boolean {
+    return this.dir
+  }
+
+  ModTime(): any {
+    return null
+  }
+
+  Mode(): number {
+    return this.dir ? ModeDir : 0
+  }
+
+  Name(): string {
+    return this.name
+  }
+
+  Size(): number {
+    return 0
+  }
+
+  Sys(): null {
+    return null
+  }
+}
+
+class singleFileFS {
+  Open(_name: string): [File, Error | null] {
+    return [null, new Error('unused')]
+  }
+
+  Stat(name: string): [FileInfo, Error | null] {
+    return [new info(name, false), null]
+  }
+}
+
+describe('io/fs WalkDir', () => {
+  it('awaits async walk callbacks', async () => {
+    const visited: string[] = []
+
+    const err = await WalkDir(new singleFileFS(), 'root.txt', async (name) => {
+      await Promise.resolve()
+      visited.push(name)
+      return null
+    })
+
+    expect(err).toBeNull()
+    expect(visited).toEqual(['root.txt'])
+  })
+})

package/gs/io/fs/walk.ts

@@ -12,19 +12,23 @@ export let SkipDir: $.GoError = errors.New('skip this directory')
 export let SkipAll: $.GoError = errors.New('skip everything and stop the walk')
 
 export type WalkDirFunc =
-  | ((path: string, d: DirEntry, err: $.GoError) => $.GoError)
+  | ((
+      path: string,
+      d: DirEntry,
+      err: $.GoError,
+    ) => $.GoError | Promise<$.GoError>)
   | null
 
 // walkDir recursively descends path, calling walkDirFn.
-export function walkDir(
+export async function walkDir(
   fsys: FS,
   name: string,
   d: DirEntry,
   walkDirFn: WalkDirFunc,
-): $.GoError {
+): Promise<$.GoError> {
   // Successfully skipped directory.
   {
-    let err = walkDirFn!(name, d, null)
+    let err = await walkDirFn!(name, d, null)
     if (err != null || !d!.IsDir()) {
       // Successfully skipped directory.
       if (err == SkipDir && d!.IsDir()) {
@@ -40,7 +44,7 @@ export function walkDir(
   // Second call, to report ReadDir error.
   if (err != null) {
     // Second call, to report ReadDir error.
-    err = walkDirFn!(name, d, err)
+    err = await walkDirFn!(name, d, err)
     if (err != null) {
       if (err == SkipDir && d!.IsDir()) {
         err = null
@@ -54,7 +58,7 @@ export function walkDir(
     {
       let name1 = path.Join(name, d1!.Name())
       {
-        let err = walkDir(fsys, name1, d1, walkDirFn)
+        let err = await walkDir(fsys, name1, d1, walkDirFn)
         if (err != null) {
           if (err == SkipDir) {
             break
@@ -79,12 +83,16 @@ export function walkDir(
 //
 // WalkDir does not follow symbolic links found in directories,
 // but if root itself is a symbolic link, its target will be walked.
-export function WalkDir(fsys: FS, root: string, fn: WalkDirFunc): $.GoError {
+export async function WalkDir(
+  fsys: FS,
+  root: string,
+  fn: WalkDirFunc,
+): Promise<$.GoError> {
   let [info, err] = Stat(fsys, root)
   if (err != null) {
-    err = fn!(root, null, err)
+    err = await fn!(root, null, err)
   } else {
-    err = walkDir(fsys, root, FileInfoToDirEntry(info), fn)
+    err = await walkDir(fsys, root, FileInfoToDirEntry(info), fn)
   }
   if (err == SkipDir || err == SkipAll) {
     return null