goscript 0.2.5 → 0.2.7

package/gs/sync/sync.test.ts

@@ -2,7 +2,18 @@ import { describe, expect, it } from 'vitest'
 
 import * as $ from '@goscript/builtin/index.js'
 
-import { Cond, Map, Mutex, Pool, RWMutex, WaitGroup } from './sync.js'
+import {
+  Cond,
+  Map,
+  Mutex,
+  Once,
+  OnceFunc,
+  OnceValue,
+  OnceValues,
+  Pool,
+  RWMutex,
+  WaitGroup,
+} from './sync.js'
 
 describe('sync.WaitGroup', () => {
   it('Go tracks scheduled work and unblocks Wait after completion', async () => {
@@ -44,6 +55,103 @@ describe('sync.RWMutex', () => {
     await locker.Lock()
     locker.Unlock()
   })
+
+  it('blocks new readers while a writer is waiting', async () => {
+    const rw = new RWMutex()
+    const events: string[] = []
+
+    await rw.RLock()
+    const writer = rw.Lock().then(() => {
+      events.push('writer')
+    })
+    const reader = rw.RLock().then(() => {
+      events.push('reader')
+    })
+    await Promise.resolve()
+
+    expect(events).toEqual([])
+    expect(rw.TryRLock()).toBe(false)
+
+    rw.RUnlock()
+    await writer
+    expect(events).toEqual(['writer'])
+
+    rw.Unlock()
+    await reader
+    expect(events).toEqual(['writer', 'reader'])
+    rw.RUnlock()
+  })
+})
+
+describe('sync.Once', () => {
+  it('marks Do complete even when f panics', async () => {
+    const once = new Once()
+    let calls = 0
+
+    await expect(
+      once.Do(() => {
+        calls++
+        throw new Error('boom')
+      }),
+    ).rejects.toThrow('boom')
+    await once.Do(() => {
+      calls++
+    })
+
+    expect(calls).toBe(1)
+  })
+
+  it('OnceFunc and OnceValue helpers replay the first panic', () => {
+    let funcCalls = 0
+    const fn = OnceFunc(() => {
+      funcCalls++
+      throw new Error('func panic')
+    })
+
+    expect(fn).toThrow('func panic')
+    expect(fn).toThrow('func panic')
+    expect(funcCalls).toBe(1)
+
+    let valueCalls = 0
+    const value = OnceValue(() => {
+      valueCalls++
+      throw new Error('value panic')
+    })
+
+    expect(value).toThrow('value panic')
+    expect(value).toThrow('value panic')
+    expect(valueCalls).toBe(1)
+
+    let valuesCalls = 0
+    const values = OnceValues(() => {
+      valuesCalls++
+      throw new Error('values panic')
+    })
+
+    expect(values).toThrow('values panic')
+    expect(values).toThrow('values panic')
+    expect(valuesCalls).toBe(1)
+  })
+
+  it('OnceValue helpers return the first successful result', () => {
+    let valueCalls = 0
+    const value = OnceValue(() => {
+      valueCalls++
+      return 'first'
+    })
+    let valuesCalls = 0
+    const values = OnceValues(() => {
+      valuesCalls++
+      return ['left', 'right'] as [string, string]
+    })
+
+    expect(value()).toBe('first')
+    expect(value()).toBe('first')
+    expect(valueCalls).toBe(1)
+    expect(values()).toEqual(['left', 'right'])
+    expect(values()).toEqual(['left', 'right'])
+    expect(valuesCalls).toBe(1)
+  })
 })
 
 describe('sync.Map', () => {

package/gs/sync/sync.ts

@@ -28,8 +28,7 @@ export class Mutex implements Locker {
       return
     }
 
-    // In a real implementation, this would block the goroutine
-    // Use Promise to simulate blocking behavior like channels
+    // GoScript lowers goroutine blocking to async suspension.
     return new Promise<void>((resolve) => {
       this._waitQueue.push(resolve)
     })
@@ -56,7 +55,6 @@ export class Mutex implements Locker {
     if (this._waitQueue.length > 0) {
       const next = this._waitQueue.shift()!
       this._locked = true
-      // Use queueMicrotask to simulate goroutine scheduling
       queueMicrotask(() => next())
     }
   }
@@ -111,7 +109,7 @@ export class RWMutex {
 
   // RLock locks rw for reading
   public async RLock(): Promise<void> {
-    if (!this._writer) {
+    if (!this._writer && this._writerWaitQueue.length === 0) {
       this._readers++
       return
     }
@@ -126,7 +124,7 @@ export class RWMutex {
 
   // TryRLock tries to lock rw for reading and reports whether it succeeded
   public TryRLock(): boolean {
-    if (!this._writer) {
+    if (!this._writer && this._writerWaitQueue.length === 0) {
       this._readers++
       return true
     }
@@ -254,8 +252,8 @@ export class Once {
     await this._m.Lock()
     try {
       if (!this._done) {
-        await f()
         this._done = true
+        await f()
       }
     } finally {
       this._m.Unlock()
@@ -512,10 +510,22 @@ export class Pool {
 // OnceFunc returns a function that invokes f only once
 export function OnceFunc(f: () => void): () => void {
   let called = false
+  let panicked = false
+  let panicValue: unknown
   return () => {
-    if (!called) {
-      called = true
+    if (called) {
+      if (panicked) {
+        throw panicValue
+      }
+      return
+    }
+    called = true
+    try {
       f()
+    } catch (err) {
+      panicked = true
+      panicValue = err
+      throw err
     }
   }
 }
@@ -524,10 +534,22 @@ export function OnceFunc(f: () => void): () => void {
 export function OnceValue<T>(f: () => T): () => T {
   let value: T
   let called = false
+  let panicked = false
+  let panicValue: unknown
   return () => {
-    if (!called) {
-      called = true
+    if (called) {
+      if (panicked) {
+        throw panicValue
+      }
+      return value
+    }
+    called = true
+    try {
       value = f()
+    } catch (err) {
+      panicked = true
+      panicValue = err
+      throw err
     }
     return value
   }
@@ -538,10 +560,22 @@ export function OnceValues<T1, T2>(f: () => [T1, T2]): () => [T1, T2] {
   let value1: T1
   let value2: T2
   let called = false
+  let panicked = false
+  let panicValue: unknown
   return () => {
-    if (!called) {
-      called = true
+    if (called) {
+      if (panicked) {
+        throw panicValue
+      }
+      return [value1, value2]
+    }
+    called = true
+    try {
       ;[value1, value2] = f()
+    } catch (err) {
+      panicked = true
+      panicValue = err
+      throw err
     }
     return [value1, value2]
   }

package/gs/syscall/fs.ts

@@ -95,7 +95,7 @@ export function Fsync(_fd: number): $.GoError {
   return ENOSYS
 }
 
-export function Ftruncate(_fd: number, _length: number): $.GoError {
+export function Ftruncate(_fd: number, _length: bigint): $.GoError {
   return ENOSYS
 }
 
@@ -113,7 +113,7 @@ export function ReadDirent(
 export function Pread(
   _fd: number,
   _b: $.Bytes | null,
-  _offset: number,
+  _offset: bigint,
 ): [number, $.GoError] {
   return [0, ENOSYS]
 }
@@ -121,17 +121,17 @@ export function Pread(
 export function Pwrite(
   _fd: number,
   _b: $.Bytes | null,
-  _offset: number,
+  _offset: bigint,
 ): [number, $.GoError] {
   return [0, ENOSYS]
 }
 
 export function Seek(
   _fd: number,
-  _offset: number,
+  _offset: bigint,
   _whence: number,
-): [number, $.GoError] {
-  return [0, ENOSYS]
+): [bigint, $.GoError] {
+  return [0n, ENOSYS]
 }
 
 export function Write(_fd: number, _b: $.Bytes | null): [number, $.GoError] {
@@ -213,11 +213,11 @@ export function SendmsgN(
   return [0, ENOSYS]
 }
 
-export function SetReadDeadline(_fd: number, _t: number): $.GoError {
+export function SetReadDeadline(_fd: number, _t: bigint): $.GoError {
   return ENOSYS
 }
 
-export function SetWriteDeadline(_fd: number, _t: number): $.GoError {
+export function SetWriteDeadline(_fd: number, _t: bigint): $.GoError {
   return ENOSYS
 }
 

package/gs/syscall/net.test.ts

@@ -102,7 +102,7 @@ describe('syscall network stubs', () => {
     expect(ReadDirent(-1, null)).toEqual([0, ENOSYS])
     expect(Pread(-1, null, 0)).toEqual([0, ENOSYS])
     expect(Pwrite(-1, null, 0)).toEqual([0, ENOSYS])
-    expect(Seek(-1, 0, 0)).toEqual([0, ENOSYS])
+    expect(Seek(-1, 0n, 0)).toEqual([0n, ENOSYS])
     expect(Write(-1, null)).toEqual([0, ENOSYS])
     expect(Dup(-1)).toEqual([0, ENOSYS])
     expect(readv(-1, [new Iovec()])).toEqual([0, ENOSYS])

package/gs/time/parse.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  FixedZone,
+  Hour,
+  Now,
+  Parse,
+  ParseInLocation,
+  RFC3339,
+  Since,
+  Until,
+} from './index.js'
+
+// Reference Unix seconds are produced by Go's time package for the same input.
+describe('time parse/since/until (Go semantics)', () => {
+  it('Parse reads an RFC3339 timestamp as UTC', () => {
+    const [t, err] = Parse(RFC3339, '2026-06-22T15:04:05Z')
+    expect(err).toBeNull()
+    expect(t.Unix()).toBe(1782140645n)
+  })
+
+  it('ParseInLocation honors the zone offset', () => {
+    const [t, err] = ParseInLocation(
+      RFC3339,
+      '2026-06-22T15:04:05+01:00',
+      FixedZone('X', 3600),
+    )
+    expect(err).toBeNull()
+    expect(t.Unix()).toBe(1782137045n)
+  })
+
+  it('Since measures elapsed time as a positive delta', () => {
+    const past = Now().Add(-Hour)
+    const elapsed = Since(past)
+    expect(elapsed >= Hour).toBe(true)
+    expect(elapsed < Hour + 5n * 1000000000n).toBe(true)
+  })
+
+  it('Until measures remaining time toward a future instant', () => {
+    const future = Now().Add(Hour)
+    const remaining = Until(future)
+    expect(remaining <= Hour).toBe(true)
+    expect(remaining > Hour - 5n * 1000000000n).toBe(true)
+  })
+})

package/gs/time/time.test.ts

@@ -37,44 +37,47 @@ import {
   Sunday,
   May,
   Time,
+  Tick,
   UTC,
+  UnixMicro,
+  UnixMilli,
 } from './time.js'
 import type { Month } from './time.js'
 
 describe('time.Duration_String', () => {
   it('formats common durations', () => {
-    expect(Duration_String(0)).toBe('0s')
-    expect(Duration_String(1500 * Millisecond)).toBe('1.5s')
-    expect(Duration_String(-1500 * Millisecond)).toBe('-1.5s')
-    expect(Duration_String(2 * Second)).toBe('2s')
-    expect(Duration_String(9 * Millisecond)).toBe('9ms')
-    expect(Duration_String(1500 * Microsecond)).toBe('1.5ms')
-    expect(Duration_String(1500)).toBe('1.5\u00b5s')
-    expect(Duration_String(12)).toBe('12ns')
+    expect(Duration_String(0n)).toBe('0s')
+    expect(Duration_String(1500n * Millisecond)).toBe('1.5s')
+    expect(Duration_String(-1500n * Millisecond)).toBe('-1.5s')
+    expect(Duration_String(2n * Second)).toBe('2s')
+    expect(Duration_String(9n * Millisecond)).toBe('9ms')
+    expect(Duration_String(1500n * Microsecond)).toBe('1.5ms')
+    expect(Duration_String(1500n)).toBe('1.5\u00b5s')
+    expect(Duration_String(12n)).toBe('12ns')
   })
 })
 
 describe('time.Duration methods', () => {
   it('converts to integer and fractional units', () => {
-    expect(Duration_Nanoseconds(1500 * Microsecond)).toBe(1500000)
-    expect(Duration_Microseconds(1500 * Microsecond)).toBe(1500)
-    expect(Duration_Milliseconds(1500 * Microsecond)).toBe(1)
-    expect(Duration_Seconds(1500 * Millisecond)).toBe(1.5)
-    expect(Duration_Minutes(90 * Second)).toBe(1.5)
-    expect(Duration_Hours(90 * Minute)).toBe(1.5)
+    expect(Duration_Nanoseconds(1500n * Microsecond)).toBe(1500000n)
+    expect(Duration_Microseconds(1500n * Microsecond)).toBe(1500n)
+    expect(Duration_Milliseconds(1500n * Microsecond)).toBe(1n)
+    expect(Duration_Seconds(1500n * Millisecond)).toBe(1.5)
+    expect(Duration_Minutes(90n * Second)).toBe(1.5)
+    expect(Duration_Hours(90n * Minute)).toBe(1.5)
   })
 
   it('rounds and truncates with Go duration semantics', () => {
-    expect(Duration_Truncate(1500 * Millisecond, Second)).toBe(Second)
-    expect(Duration_Truncate(-1500 * Millisecond, Second)).toBe(-Second)
-    expect(Duration_Round(1500 * Millisecond, Second)).toBe(2 * Second)
-    expect(Duration_Round(-1500 * Millisecond, Second)).toBe(-2 * Second)
-    expect(Duration_Round(1500 * Millisecond, 0)).toBe(1500 * Millisecond)
+    expect(Duration_Truncate(1500n * Millisecond, Second)).toBe(Second)
+    expect(Duration_Truncate(-1500n * Millisecond, Second)).toBe(-Second)
+    expect(Duration_Round(1500n * Millisecond, Second)).toBe(2n * Second)
+    expect(Duration_Round(-1500n * Millisecond, Second)).toBe(-2n * Second)
+    expect(Duration_Round(1500n * Millisecond, 0n)).toBe(1500n * Millisecond)
   })
 
   it('returns absolute values', () => {
-    expect(Duration_Abs(2 * Second)).toBe(2 * Second)
-    expect(Duration_Abs(-2 * Second)).toBe(2 * Second)
+    expect(Duration_Abs(2n * Second)).toBe(2n * Second)
+    expect(Duration_Abs(-2n * Second)).toBe(2n * Second)
   })
 })
 
@@ -113,6 +116,12 @@ describe('time constants and timers', () => {
 
     expect(value.Unix()).toBeGreaterThan(0)
   })
+
+  it('delivers Tick values on C', async () => {
+    const value = await Tick(0).receive()
+
+    expect(value.Unix()).toBeGreaterThan(0)
+  })
 })
 
 describe('time.Time.In', () => {
@@ -134,6 +143,16 @@ describe('time.Time.In', () => {
 })
 
 describe('time.Time calendar and binary helpers', () => {
+  it('round-trips Unix millisecond and microsecond constructors', () => {
+    const millis = UnixMilli(1234567890123n)
+    const micros = UnixMicro(1234567890123456n)
+
+    expect(millis.UnixMilli()).toBe(1234567890123n)
+    expect(millis.Unix()).toBe(1234567890n)
+    expect(micros.UnixMicro()).toBe(1234567890123456n)
+    expect(micros.Unix()).toBe(1234567890n)
+  })
+
   it('appends formatted text to byte slices', () => {
     const t = Date(2025, May, 15, 1, 10, 42, 0, UTC)
     const out = t.AppendFormat($.stringToBytes('ts='), RFC3339)
@@ -175,11 +194,15 @@ describe('time.Time calendar and binary helpers', () => {
     )
 
     expect(utc.MarshalBinary()).toEqual([
-      new Uint8Array([1, 0, 0, 0, 14, 223, 183, 54, 18, 7, 91, 205, 21, 255, 255]),
+      new Uint8Array([
+        1, 0, 0, 0, 14, 223, 183, 54, 18, 7, 91, 205, 21, 255, 255,
+      ]),
       null,
     ])
     expect(pdt.MarshalBinary()).toEqual([
-      new Uint8Array([1, 0, 0, 0, 14, 223, 183, 54, 18, 7, 91, 205, 21, 254, 92]),
+      new Uint8Array([
+        1, 0, 0, 0, 14, 223, 183, 54, 18, 7, 91, 205, 21, 254, 92,
+      ]),
       null,
     ])
   })