goscript 0.0.84 → 0.1.1

package/gs/syscall/js/index.ts

@@ -0,0 +1,458 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export type Type = number
+
+export const TypeUndefined: Type = 0
+export const TypeNull: Type = 1
+export const TypeBoolean: Type = 2
+export const TypeNumber: Type = 3
+export const TypeString: Type = 4
+export const TypeSymbol: Type = 5
+export const TypeObject: Type = 6
+export const TypeFunction: Type = 7
+
+export class Value {
+  public _raw: unknown
+
+  constructor(init?: Partial<{ raw: unknown }> | unknown) {
+    if (isRawInit(init)) {
+      this._raw = init.raw
+      return
+    }
+    this._raw = init
+  }
+
+  public clone(): Value {
+    return new Value({ raw: this._raw })
+  }
+
+  public Equal(w: Value): boolean {
+    return this._raw === w._raw && !Number.isNaN(this._raw)
+  }
+
+  public IsUndefined(): boolean {
+    return this._raw === undefined
+  }
+
+  public IsNull(): boolean {
+    return this._raw === null
+  }
+
+  public IsNaN(): boolean {
+    return typeof this._raw === 'number' && Number.isNaN(this._raw)
+  }
+
+  public Type(): Type {
+    if (this._raw === undefined) {
+      return TypeUndefined
+    }
+    if (this._raw === null) {
+      return TypeNull
+    }
+    switch (typeof this._raw) {
+      case 'boolean':
+        return TypeBoolean
+      case 'number':
+        return TypeNumber
+      case 'string':
+        return TypeString
+      case 'symbol':
+        return TypeSymbol
+      case 'function':
+        return TypeFunction
+      case 'object':
+        return TypeObject
+      default:
+        $.panic('bad type')
+    }
+  }
+
+  public Get(p: string): Value {
+    this.requireObject('Value.Get')
+    return new Value({ raw: Reflect.get(this._raw as object, p) })
+  }
+
+  public Set(p: string, x: unknown): void {
+    this.requireObject('Value.Set')
+    Reflect.set(this._raw as object, p, ValueOf(x)._raw)
+  }
+
+  public Delete(p: string): void {
+    this.requireObject('Value.Delete')
+    Reflect.deleteProperty(this._raw as object, p)
+  }
+
+  public Index(i: number): Value {
+    this.requireObject('Value.Index')
+    return new Value({ raw: Reflect.get(this._raw as object, i) })
+  }
+
+  public SetIndex(i: number, x: unknown): void {
+    this.requireObject('Value.SetIndex')
+    Reflect.set(this._raw as object, i, ValueOf(x)._raw)
+  }
+
+  public Length(): number {
+    this.requireObject('Value.SetIndex')
+    return Number(Reflect.get(this._raw as object, 'length') ?? 0)
+  }
+
+  public Call(m: string, ...args: unknown[]): Value {
+    this.requireObject('Value.Call')
+    const fn = Reflect.get(this._raw as object, m)
+    if (typeof fn !== 'function') {
+      $.panic(
+        `syscall/js: Value.Call: property ${m} is not a function, got ${Type_String(ValueOf(fn).Type())}`,
+      )
+    }
+    return new Value({ raw: fn.apply(this._raw, args.map((arg) => ValueOf(arg)._raw)) })
+  }
+
+  public Invoke(...args: unknown[]): Value {
+    if (typeof this._raw !== 'function') {
+      $.panic(new ValueError({ Method: 'Value.Invoke', Type: this.Type() }))
+    }
+    return new Value({ raw: this._raw(...args.map((arg) => ValueOf(arg)._raw)) })
+  }
+
+  public New(...args: unknown[]): Value {
+    if (typeof this._raw !== 'function') {
+      $.panic(new ValueError({ Method: 'Value.Invoke', Type: this.Type() }))
+    }
+    return new Value({
+      raw: Reflect.construct(this._raw, args.map((arg) => ValueOf(arg)._raw)),
+    })
+  }
+
+  public InstanceOf(t: Value): boolean {
+    if (typeof t._raw !== 'function') {
+      return false
+    }
+    return this._raw instanceof t._raw
+  }
+
+  public Float(): number {
+    return this.number('Value.Float')
+  }
+
+  public Int(): number {
+    return Math.trunc(this.number('Value.Int'))
+  }
+
+  public Bool(): boolean {
+    if (typeof this._raw !== 'boolean') {
+      $.panic(new ValueError({ Method: 'Value.Bool', Type: this.Type() }))
+    }
+    return this._raw
+  }
+
+  public Truthy(): boolean {
+    return !!this._raw
+  }
+
+  public String(): string {
+    switch (this.Type()) {
+      case TypeString:
+        return this._raw as string
+      case TypeUndefined:
+        return '<undefined>'
+      case TypeNull:
+        return '<null>'
+      case TypeBoolean:
+      case TypeNumber:
+        return `<${Type_String(this.Type())}: ${String(this._raw)}>`
+      case TypeSymbol:
+        return '<symbol>'
+      case TypeObject:
+        return '<object>'
+      case TypeFunction:
+        return '<function>'
+      default:
+        $.panic('bad type')
+    }
+  }
+
+  private requireObject(method: string): void {
+    if (!Type_isObject(this.Type())) {
+      $.panic(new ValueError({ Method: method, Type: this.Type() }))
+    }
+  }
+
+  private number(method: string): number {
+    if (typeof this._raw !== 'number') {
+      $.panic(new ValueError({ Method: method, Type: this.Type() }))
+    }
+    return this._raw
+  }
+}
+
+export class Error {
+  public Value: Value
+
+  constructor(init?: Partial<Error>) {
+    this.Value = init?.Value?.clone() ?? Undefined()
+  }
+
+  public clone(): Error {
+    return new Error({ Value: this.Value })
+  }
+
+  public Error(): string {
+    return `JavaScript error: ${this.Value.Get('message').String()}`
+  }
+}
+
+export class ValueError {
+  public Method: string
+  public Type: Type
+
+  constructor(init?: Partial<ValueError>) {
+    this.Method = init?.Method ?? ''
+    this.Type = init?.Type ?? TypeUndefined
+  }
+
+  public clone(): ValueError {
+    return new ValueError({ Method: this.Method, Type: this.Type })
+  }
+
+  public Error(): string {
+    return `syscall/js: call of ${this.Method} on ${Type_String(this.Type)}`
+  }
+}
+
+export class Func {
+  public Value: Value
+  private _released = false
+
+  constructor(init?: Partial<Func> & { fn?: (this$: Value, args: $.Slice<Value>) => unknown }) {
+    const fn = init?.fn
+    this.Value = init?.Value?.clone() ?? new Value({
+      raw: function (this: unknown, ...args: unknown[]) {
+        if (fn === undefined) {
+          return undefined
+        }
+        return ValueOf(
+          fn(
+            new Value({ raw: this }),
+            args.map((arg) => new Value({ raw: arg })) as $.Slice<Value>,
+          ),
+        )._raw
+      },
+    })
+  }
+
+  public clone(): Func {
+    return new Func({ Value: this.Value })
+  }
+
+  public Release(): void {
+    this._released = true
+  }
+
+  public Equal(w: Value): boolean {
+    return this.Value.Equal(w)
+  }
+
+  public IsUndefined(): boolean {
+    return this.Value.IsUndefined()
+  }
+
+  public IsNull(): boolean {
+    return this.Value.IsNull()
+  }
+
+  public IsNaN(): boolean {
+    return this.Value.IsNaN()
+  }
+
+  public Type(): Type {
+    return this.Value.Type()
+  }
+
+  public Get(p: string): Value {
+    return this.Value.Get(p)
+  }
+
+  public Set(p: string, x: unknown): void {
+    this.Value.Set(p, x)
+  }
+
+  public Delete(p: string): void {
+    this.Value.Delete(p)
+  }
+
+  public Index(i: number): Value {
+    return this.Value.Index(i)
+  }
+
+  public SetIndex(i: number, x: unknown): void {
+    this.Value.SetIndex(i, x)
+  }
+
+  public Length(): number {
+    return this.Value.Length()
+  }
+
+  public Call(m: string, ...args: unknown[]): Value {
+    return this.Value.Call(m, ...args)
+  }
+
+  public Invoke(...args: unknown[]): Value {
+    return this.Value.Invoke(...args)
+  }
+
+  public New(...args: unknown[]): Value {
+    return this.Value.New(...args)
+  }
+
+  public InstanceOf(t: Value): boolean {
+    return this.Value.InstanceOf(t)
+  }
+
+  public Float(): number {
+    return this.Value.Float()
+  }
+
+  public Int(): number {
+    return this.Value.Int()
+  }
+
+  public Bool(): boolean {
+    return this.Value.Bool()
+  }
+
+  public Truthy(): boolean {
+    return this.Value.Truthy()
+  }
+
+  public String(): string {
+    return this.Value.String()
+  }
+}
+
+export function Undefined(): Value {
+  return new Value({ raw: undefined })
+}
+
+export function Null(): Value {
+  return new Value({ raw: null })
+}
+
+export function Global(): Value {
+  return new Value({ raw: globalThis })
+}
+
+export function ValueOf(x: unknown): Value {
+  if (x instanceof Value) {
+    return x.clone()
+  }
+  if (x instanceof Func) {
+    return x.Value.clone()
+  }
+  if (x === null || x === undefined) {
+    return Null()
+  }
+  if (typeof x === 'boolean' || typeof x === 'number' || typeof x === 'string') {
+    return new Value({ raw: x })
+  }
+  if (typeof x === 'bigint') {
+    return new Value({ raw: Number(x) })
+  }
+  if (x instanceof Uint8Array) {
+    return new Value({ raw: x })
+  }
+  if (Array.isArray(x)) {
+    return new Value({ raw: x.map((item) => ValueOf(item)._raw) })
+  }
+  if (x instanceof Map) {
+    const out: Record<string, unknown> = {}
+    for (const [key, value] of x.entries()) {
+      out[String(key)] = ValueOf(value)._raw
+    }
+    return new Value({ raw: out })
+  }
+  return new Value({ raw: x })
+}
+
+export function FuncOf(
+  fn: (this$: Value, args: $.Slice<Value>) => unknown,
+): Func {
+  return new Func({ fn })
+}
+
+export function Type_String(t: Type): string {
+  switch (t) {
+    case TypeUndefined:
+      return 'undefined'
+    case TypeNull:
+      return 'null'
+    case TypeBoolean:
+      return 'boolean'
+    case TypeNumber:
+      return 'number'
+    case TypeString:
+      return 'string'
+    case TypeSymbol:
+      return 'symbol'
+    case TypeObject:
+      return 'object'
+    case TypeFunction:
+      return 'function'
+    default:
+      $.panic('bad type')
+  }
+}
+
+export function Type_isObject(t: Type): boolean {
+  return t === TypeObject || t === TypeFunction
+}
+
+export function CopyBytesToGo(dst: $.Bytes | null, src: Value): number {
+  const bytes = sourceBytes(src)
+  const n = Math.min($.len(dst), bytes.length)
+  if (dst instanceof Uint8Array) {
+    dst.set(bytes.subarray(0, n), 0)
+    return n
+  }
+  const arr = $.asArray(dst)
+  for (let i = 0; i < n; i++) {
+    arr[i] = bytes[i]
+  }
+  return n
+}
+
+export function CopyBytesToJS(dst: Value, src: $.Bytes | null): number {
+  const target = dstRawBytes(dst)
+  const bytes = src instanceof Uint8Array ? src : Uint8Array.from($.asArray(src))
+  const n = Math.min(target.length, bytes.length)
+  target.set(bytes.subarray(0, n), 0)
+  return n
+}
+
+function sourceBytes(src: Value): Uint8Array {
+  const raw = srcRaw(src)
+  if (raw instanceof Uint8Array || raw instanceof Uint8ClampedArray) {
+    return raw instanceof Uint8Array ? raw : new Uint8Array(raw.buffer, raw.byteOffset, raw.byteLength)
+  }
+  $.panic('syscall/js: CopyBytesToGo: expected src to be a Uint8Array or Uint8ClampedArray')
+}
+
+function dstRawBytes(dst: Value): Uint8Array | Uint8ClampedArray {
+  const raw = srcRaw(dst)
+  if (raw instanceof Uint8Array || raw instanceof Uint8ClampedArray) {
+    return raw
+  }
+  $.panic('syscall/js: CopyBytesToJS: expected dst to be a Uint8Array or Uint8ClampedArray')
+}
+
+function srcRaw(value: Value): unknown {
+  return (value as unknown as { _raw: unknown })._raw
+}
+
+function isRawInit(value: unknown): value is { raw: unknown } {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    Object.prototype.hasOwnProperty.call(value, 'raw')
+  )
+}

package/gs/syscall/js/meta.json

@@ -0,0 +1,4 @@
+{
+  "dependencies": [],
+  "asyncMethods": {}
+}

package/gs/syscall/net.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  Bind,
+  Close,
+  CloseOnExec,
+  Connect,
+  Dup,
+  ENOSYS,
+  ENOTSUP,
+  GetsockoptInt,
+  Iovec,
+  IPPROTO_IPV6,
+  IPPROTO_TCP,
+  IPV6_V6ONLY,
+  Listen,
+  Pread,
+  Pwrite,
+  Read,
+  ReadDirent,
+  Recvfrom,
+  Recvmsg,
+  Seek,
+  SendmsgN,
+  Sendto,
+  SetReadDeadline,
+  SetNonblock,
+  SetsockoptInt,
+  SetWriteDeadline,
+  Shutdown,
+  SOCK_SEQPACKET,
+  SOMAXCONN,
+  Socket,
+  StopIO,
+  Write,
+  readv,
+  writev,
+} from './index.js'
+
+describe('syscall network stubs', () => {
+  test('exports network constants used by generated net', () => {
+    expect(SOCK_SEQPACKET).toBe(5)
+    expect(IPPROTO_IPV6).toBe(0x29)
+    expect(IPPROTO_TCP).toBe(6)
+    expect(IPV6_V6ONLY).toBe(0x1a)
+    expect(SOMAXCONN).toBe(0x80)
+    expect(ENOTSUP.Error()).toBe('operation not supported')
+  })
+
+  test('reports unsupported socket operations as syscall errors', () => {
+    expect(Socket(0, 0, 0)).toEqual([-1, ENOSYS])
+    expect(Connect(-1, null)).toBe(ENOSYS)
+    expect(Listen(-1, 0)).toBe(ENOSYS)
+    expect(Bind(-1, null)).toBe(ENOSYS)
+    expect(StopIO(-1)).toBe(ENOSYS)
+    expect(Recvfrom(-1, null, 0)).toEqual([0, null, ENOSYS])
+    expect(Sendto(-1, null, 0, null)).toBe(ENOSYS)
+    expect(Recvmsg(-1, null, null, 0)).toEqual([0, 0, 0, null, ENOSYS])
+    expect(SendmsgN(-1, null, null, null, 0)).toEqual([0, ENOSYS])
+    expect(GetsockoptInt(-1, 0, 0)).toEqual([0, ENOSYS])
+    expect(SetsockoptInt(-1, 0, 0, 0)).toBeNull()
+    expect(SetReadDeadline(-1, 0)).toBe(ENOSYS)
+    expect(SetWriteDeadline(-1, 0)).toBe(ENOSYS)
+    expect(Shutdown(-1, 0)).toBe(ENOSYS)
+  })
+
+  test('exports JavaScript no-op descriptor flag helpers', () => {
+    expect(Close(1)).toBeNull()
+    expect(CloseOnExec(1)).toBeUndefined()
+    expect(SetNonblock(1, true)).toBeNull()
+    expect(SetNonblock(1, false)).toBeNull()
+  })
+
+  test('exports unsupported descriptor operations', () => {
+    expect(Read(-1, null)).toEqual([0, ENOSYS])
+    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(Write(-1, null)).toEqual([0, ENOSYS])
+    expect(Dup(-1)).toEqual([0, ENOSYS])
+    expect(readv(-1, [new Iovec()])).toEqual([0, ENOSYS])
+    expect(writev(-1, [new Iovec()])).toEqual([0, ENOSYS])
+  })
+})

package/gs/syscall/types.ts

@@ -16,3 +16,59 @@ export interface RawConn {
   Read(f: (fd: uintptr) => boolean): $.GoError
   Write(f: (fd: uintptr) => boolean): $.GoError
 }
+
+export interface Sockaddr {}
+
+export class SockaddrInet4 implements Sockaddr {
+  public Port: number = 0
+  public Addr: Uint8Array = new Uint8Array(4)
+
+  constructor(init?: Partial<SockaddrInet4>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrInet4 {
+    return new SockaddrInet4({
+      Port: this.Port,
+      Addr: new Uint8Array(this.Addr),
+    })
+  }
+}
+
+export class SockaddrInet6 implements Sockaddr {
+  public Port: number = 0
+  public ZoneId: number = 0
+  public Addr: Uint8Array = new Uint8Array(16)
+
+  constructor(init?: Partial<SockaddrInet6>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrInet6 {
+    return new SockaddrInet6({
+      Port: this.Port,
+      ZoneId: this.ZoneId,
+      Addr: new Uint8Array(this.Addr),
+    })
+  }
+}
+
+export class SockaddrUnix implements Sockaddr {
+  public Name: string = ''
+
+  constructor(init?: Partial<SockaddrUnix>) {
+    if (init) {
+      Object.assign(this, init)
+    }
+  }
+
+  public clone(): SockaddrUnix {
+    return new SockaddrUnix({ Name: this.Name })
+  }
+}
+
+export class Iovec {}

package/gs/testing/index.ts

@@ -0,0 +1 @@
+export * from './testing.js'

package/gs/testing/meta.json

@@ -0,0 +1,5 @@
+{
+  "asyncMethods": {
+    "T.Run": true
+  }
+}

package/gs/testing/testing.test.ts

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest'
+
+import { B, F, Short, T, type TB } from './testing.js'
+import { runTests } from './testing.js'
+
+describe('testing.T', () => {
+  it('runs passing subtests', async () => {
+    const t = new T('root')
+
+    const ok = await t.Run('child', (child) => {
+      expect(child.Name()).toBe('root/child')
+    })
+
+    expect(ok).toBe(true)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('runs async subtests before returning', async () => {
+    const t = new T('root')
+    let completed = false
+
+    const ok = await t.Run('child', async (child) => {
+      await Promise.resolve()
+      expect(child.Name()).toBe('root/child')
+      completed = true
+    })
+
+    expect(ok).toBe(true)
+    expect(completed).toBe(true)
+    expect(t.Failed()).toBe(false)
+  })
+
+  it('propagates failed subtests', async () => {
+    const t = new T('root')
+
+    const ok = await t.Run('child', (child) => {
+      child.Error('failed')
+    })
+
+    expect(ok).toBe(false)
+    expect(t.Failed()).toBe(true)
+  })
+
+  it('exports the benchmark and fuzz test surfaces used by compiled tests', async () => {
+    const b = new B('bench')
+    b.N = 2
+    b.ReportAllocs()
+    b.ResetTimer()
+    b.SetBytes(12)
+    b.ReportMetric(3, 'items')
+
+    let ran = false
+    const ok = await b.Run('child', (child) => {
+      ran = true
+      expect(child.Name()).toBe('bench/child')
+    })
+
+    const f = new F('fuzz')
+    f.Add('seed')
+    f.Fuzz(() => {})
+
+    const tb: TB = b
+    tb.Helper()
+
+    expect(ok).toBe(true)
+    expect(ran).toBe(true)
+    expect(Short()).toBe(false)
+  })
+
+  it('reports short mode while a short run is active', async () => {
+    let observed = false
+
+    const result = await runTests(
+      'example.test/short',
+      [
+        {
+          name: 'TestShort',
+          fn: () => {
+            observed = Short()
+          },
+        },
+      ],
+      { short: true },
+    )
+
+    expect(result.ok).toBe(true)
+    expect(observed).toBe(true)
+    expect(Short()).toBe(false)
+  })
+})