goscript 0.0.84 → 0.1.0

package/gs/builtin/runtime-contract.test.ts

@@ -0,0 +1,230 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  byte,
+  callGenericMethod,
+  chanRecvWithOk,
+  functionValue,
+  genericZero,
+  int,
+  interfaceValue,
+  makeChannel,
+  makeMap,
+  mapGet,
+  mapSet,
+  markAsStructValue,
+  namedFunction,
+  newError,
+  pointerValue,
+  print,
+  println,
+  registerInterfaceType,
+  registerStructType,
+  resetHostRuntimeForTests,
+  TypeKind,
+  typeAssert,
+  typedNil,
+  unref,
+  varRef,
+} from './index.js'
+
+const originalDeno = (globalThis as any).Deno
+const originalProcess = (globalThis as any).process
+
+afterEach(() => {
+  vi.restoreAllMocks()
+
+  if (originalDeno === undefined) {
+    delete (globalThis as any).Deno
+  } else {
+    ;(globalThis as any).Deno = originalDeno
+  }
+
+  if (originalProcess === undefined) {
+    delete (globalThis as any).process
+  } else {
+    ;(globalThis as any).process = originalProcess
+  }
+
+  resetHostRuntimeForTests()
+})
+
+describe('builtin runtime contract helpers', () => {
+  it('writes print and println through the host runtime owner', () => {
+    const writes: Array<{ fd: number; text: string }> = []
+    const writeSync = vi.fn(
+      (
+        fd: number,
+        buffer: Uint8Array,
+        _offset?: number,
+        length?: number,
+        _position?: number | null,
+      ) => {
+        writes.push({
+          fd,
+          text: new TextDecoder().decode(
+            buffer.subarray(0, length ?? buffer.length),
+          ),
+        })
+        return length ?? buffer.length
+      },
+    )
+
+    delete (globalThis as any).Deno
+    ;(globalThis as any).process = {
+      getBuiltinModule: vi.fn(() => ({
+        readSync: vi.fn(),
+        writeSync,
+      })),
+    }
+    resetHostRuntimeForTests()
+
+    print('value:', 3)
+    println('done')
+
+    expect(writes).toEqual([
+      { fd: 1, text: 'value: 3' },
+      { fd: 1, text: 'done\n' },
+    ])
+  })
+
+  it('exposes numeric, varref, map, and error helpers', () => {
+    expect(int(1.9)).toBe(1)
+    expect(byte(257)).toBe(1)
+
+    const value = varRef(4)
+    value.value = 8
+    expect(unref(value)).toBe(8)
+    expect(pointerValue(value)).toBe(8)
+    expect(pointerValue({ ok: true })).toEqual({ ok: true })
+    expect(() => pointerValue(null)).toThrow('nil pointer dereference')
+
+    const m = makeMap<string, number>()
+    mapSet(m, 'answer', 42)
+    expect(mapGet(m, 'answer', 0)).toEqual([42, true])
+    expect(mapGet(m, 'missing', 0)).toEqual([0, false])
+
+    expect(newError('bad')?.Error()).toBe('bad')
+  })
+
+  it('exposes value and type descriptor helpers', () => {
+    class Runner {
+      public Run(): string {
+        return 'ok'
+      }
+    }
+
+    const runnerType = registerStructType(
+      'phase5.Runner',
+      markAsStructValue(new Runner()),
+      [{ name: 'Run', args: [], returns: [{ type: 'string' }] }],
+      Runner,
+    )
+    const runnerInterface = registerInterfaceType(
+      'phase5.RunnerInterface',
+      null,
+      [{ name: 'Run', args: [], returns: [{ type: 'string' }] }],
+    )
+
+    const value = new Runner()
+    expect(markAsStructValue(value)).toBe(value)
+    expect(typeAssert<Runner>(value, runnerType)).toEqual({
+      ok: true,
+      value,
+    })
+    expect(typeAssert<Runner>(new Runner(), runnerInterface).ok).toBe(true)
+    expect(typeAssert<Runner>(null, runnerInterface).ok).toBe(false)
+
+    const nil = typedNil('*main.Example')
+    expect(nil.__isTypedNil).toBe(true)
+    expect(nil.__goType).toBe('*main.Example')
+    expect(
+      typeAssert<Runner | null>(typedNil('*phase5.Runner'), {
+        kind: TypeKind.Pointer,
+        elemType: 'phase5.Runner',
+      }),
+    ).toEqual({ value: null, ok: true })
+    expect(TypeKind.Pointer).toBe('pointer')
+
+    class TypedDog {
+      public Name(this: TypedDog | null): string {
+        if (this === null) {
+          return 'unknown dog'
+        }
+        return 'dog'
+      }
+    }
+
+    registerStructType(
+      'phase5.TypedDog',
+      new TypedDog(),
+      [{ name: 'Name', args: [], returns: [{ type: 'string' }] }],
+      TypedDog,
+    )
+    const dogInterface = registerInterfaceType(
+      'phase5.DogInterface',
+      null,
+      [{ name: 'Name', args: [], returns: [{ type: 'string' }] }],
+    )
+    const nilDog = interfaceValue<{ Name(): string } | null>(
+      null,
+      '*phase5.TypedDog',
+    )
+    expect(nilDog).not.toBeNull()
+    expect(nilDog!.Name()).toBe('unknown dog')
+    expect(typeAssert<{ Name(): string }>(nilDog, dogInterface).ok).toBe(true)
+    expect(
+      typeAssert<TypedDog | null>(nilDog, {
+        kind: TypeKind.Pointer,
+        elemType: 'phase5.TypedDog',
+      }),
+    ).toEqual({ value: null, ok: true })
+
+    const greet = namedFunction((name: string) => `hello ${name}`, 'phase5.Greet')
+    expect(typeAssert<typeof greet>(greet, {
+      kind: TypeKind.Function,
+      name: 'phase5.Greet',
+    }).ok).toBe(true)
+    expect(
+      typeAssert<{ Name: string }>(
+        { Name: 'Alice' },
+        {
+          kind: TypeKind.Struct,
+          methods: [],
+          fields: {
+            Name: {
+              type: { kind: TypeKind.Basic, name: 'string' },
+              tag: 'json:"name"',
+            },
+          },
+        },
+      ).ok,
+    ).toBe(true)
+    const literal = functionValue((value: number) => String(value), {
+      kind: TypeKind.Function,
+      params: [{ kind: TypeKind.Basic, name: 'int' }],
+      results: [{ kind: TypeKind.Basic, name: 'string' }],
+    })
+    expect(literal(7)).toBe('7')
+    expect(literal).toHaveProperty('__typeInfo')
+
+    const genericArgs = {
+      T: {
+        zero: () => 0,
+        methods: {
+          String: (value: number) => String(value),
+        },
+      },
+    }
+    expect(genericZero(genericArgs, 'T', null)).toBe(0)
+    expect(callGenericMethod(genericArgs, 'T', 'String', 12)).toBe('12')
+  })
+
+  it('exposes channel helpers used by future lowering', async () => {
+    const channel = makeChannel<number>(1, 0, 'both')
+    await channel.send(7)
+    expect(await chanRecvWithOk(channel)).toEqual({ value: 7, ok: true })
+    channel.close()
+    expect(await chanRecvWithOk(channel)).toEqual({ value: 0, ok: false })
+  })
+})

package/gs/builtin/type.ts

@@ -500,9 +500,12 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
 
     if (fieldsExist && sameFieldCount && allFieldsInStruct) {
       return Object.entries(info.fields).every(([fieldName, fieldType]) => {
+        const fieldTypeInfo = isStructFieldInfo(fieldType)
+          ? fieldType.type
+          : fieldType
         return matchesType(
           value[fieldName],
-          normalizeTypeInfo(fieldType as TypeInfo | string),
+          normalizeTypeInfo(fieldTypeInfo),
         )
       })
     }
@@ -1008,6 +1011,9 @@ export function typeAssert<T>(
 
   // Handle typed nil pointers (created by typedNil() for conversions like (*T)(nil))
   if (typeof value === 'object' && value !== null && value.__isTypedNil) {
+    if (isInterfaceTypeInfo(normalizedType) && matchesInterfaceType(value, normalizedType)) {
+      return { value: value as T, ok: true }
+    }
     // For typed nils, we need to compare the stored type with the expected type
     if (isPointerTypeInfo(normalizedType)) {
       // Parse the stored type string and compare with expected type
@@ -1219,3 +1225,80 @@ export function typedNil(typeName: string): any {
     __isTypedNil: true,
   })
 }
+
+export function interfaceValue<T>(value: unknown, typeName: string): T {
+  if (value !== null && value !== undefined) {
+    return value as T
+  }
+
+  const nilValue = typedNil(typeName)
+  if (!typeName.startsWith('*')) {
+    return nilValue as T
+  }
+
+  const dynamicType = typeRegistry.get(typeName.slice(1))
+  if (!dynamicType || !isStructTypeInfo(dynamicType) || !dynamicType.ctor) {
+    return nilValue as T
+  }
+
+  const prototype = dynamicType.ctor.prototype as Record<string, unknown>
+  for (const method of dynamicType.methods) {
+    const implementation = prototype[method.name]
+    if (typeof implementation !== 'function') {
+      continue
+    }
+    Object.defineProperty(nilValue, method.name, {
+      value: (...args: unknown[]) => implementation.call(null, ...args),
+      enumerable: true,
+    })
+  }
+  return nilValue as T
+}
+
+export function namedFunction<T>(fn: T, typeName: string): T {
+  if (typeof fn !== 'function') {
+    return fn
+  }
+  return Object.assign(fn, { __goTypeName: typeName })
+}
+
+export function functionValue<T extends (...args: any[]) => any>(
+  fn: T,
+  typeInfo: FunctionTypeInfo,
+): T {
+  return Object.assign(fn, { __typeInfo: typeInfo })
+}
+
+export interface GenericTypeDescriptor<T = any> {
+  type?: TypeInfo | string
+  zero?: () => T
+  methods?: Record<string, (receiver: T, ...args: any[]) => any>
+}
+
+export type GenericTypeArgs = Record<string, GenericTypeDescriptor>
+
+export function genericZero<T>(
+  typeArgs: GenericTypeArgs | undefined,
+  name: string,
+  fallback: T,
+): T {
+  const zero = typeArgs?.[name]?.zero
+  if (zero) {
+    return zero() as T
+  }
+  return fallback
+}
+
+export function callGenericMethod<T>(
+  typeArgs: GenericTypeArgs | undefined,
+  name: string,
+  method: string,
+  receiver: T,
+  ...args: any[]
+): any {
+  const fn = typeArgs?.[name]?.methods?.[method]
+  if (fn) {
+    return fn(receiver, ...args)
+  }
+  return (receiver as any)[method](...args)
+}

package/gs/crypto/rand/index.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Read, Reader, Text } from './index.js'
+
+describe('crypto/rand override', () => {
+  it('fills byte slices from Web Crypto', () => {
+    const buf = new Uint8Array(32)
+    const [n, err] = Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(32)
+    expect(buf.some((b) => b !== 0)).toBe(true)
+  })
+
+  it('exposes Reader as an io.Reader-compatible source', () => {
+    const buf = $.makeSlice<number>(12, 12, 'byte')
+    const [n, err] = Reader.Read(buf)
+
+    expect(err).toBeNull()
+    expect(n).toBe(12)
+    expect(Array.from(buf ?? []).some((b) => b !== 0)).toBe(true)
+  })
+
+  it('generates base32 text tokens', () => {
+    const token = Text()
+
+    expect(token).toHaveLength(26)
+    expect(token).toMatch(/^[A-Z2-7]+$/)
+  })
+})

package/gs/crypto/rand/index.ts

@@ -0,0 +1,90 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as io from '@goscript/io/index.js'
+
+const base32alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567'
+const maxGetRandomValuesBytes = 65536
+
+class RandError {
+  constructor(private readonly message: string) {}
+
+  Error(): string {
+    return this.message
+  }
+}
+
+class WebCryptoReader implements io.Reader {
+  Read(p: $.Bytes): [number, $.GoError] {
+    const err = fillSecureBytes(p)
+    if (err != null) {
+      return [0, err]
+    }
+    return [$.len(p), null]
+  }
+}
+
+export let Reader: io.Reader = new WebCryptoReader()
+
+export function Read(b: $.Bytes): [number, $.GoError] {
+  const [n, err] = Reader.Read(b)
+  if (err != null) {
+    return [n, err]
+  }
+  if (n !== $.len(b)) {
+    return [n, io.ErrUnexpectedEOF]
+  }
+  return [n, null]
+}
+
+export function Text(): string {
+  const src = new Uint8Array(26)
+  const [, err] = Read(src)
+  if (err != null) {
+    throw new Error(err.Error())
+  }
+
+  let out = ''
+  for (const b of src) {
+    out += base32alphabet[b % 32]
+  }
+  return out
+}
+
+function fillSecureBytes(dst: $.Bytes): $.GoError {
+  const length = $.len(dst)
+  if (length === 0) {
+    return null
+  }
+
+  const crypto = secureCrypto()
+  if (crypto == null) {
+    return new RandError('crypto/rand: Web Crypto getRandomValues is unavailable')
+  }
+
+  if (dst instanceof Uint8Array) {
+    fillUint8Array(crypto, dst)
+    return null
+  }
+
+  const tmp = new Uint8Array(length)
+  fillUint8Array(crypto, tmp)
+  $.copy(dst, tmp)
+  return null
+}
+
+function fillUint8Array(crypto: Crypto, dst: Uint8Array): void {
+  for (let offset = 0; offset < dst.length; offset += maxGetRandomValuesBytes) {
+    const chunk = dst.subarray(
+      offset,
+      Math.min(offset + maxGetRandomValuesBytes, dst.length),
+    ) as Uint8Array<ArrayBuffer>
+    crypto.getRandomValues(chunk)
+  }
+}
+
+function secureCrypto(): Crypto | null {
+  const crypto = globalThis.crypto
+  if (crypto && typeof crypto.getRandomValues === 'function') {
+    return crypto
+  }
+  return null
+}

package/gs/crypto/rand/meta.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": [
+    "io"
+  ]
+}

package/gs/encoding/json/index.test.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from 'vitest'
+
+import * as $ from '@goscript/builtin/index.js'
+
+import { Marshal, Unmarshal } from './index.js'
+
+class Person {
+  public _fields = {
+    Name: $.varRef(''),
+    Age: $.varRef(0),
+    Active: $.varRef(false),
+  }
+
+  static __typeInfo = $.registerStructType(
+    'test.Person',
+    new Person(),
+    [],
+    Person,
+    {
+      Name: { type: { kind: $.TypeKind.Basic, name: 'string' }, tag: 'json:"name"' },
+      Age: { type: { kind: $.TypeKind.Basic, name: 'int' }, tag: 'json:"age"' },
+      Active: { type: { kind: $.TypeKind.Basic, name: 'bool' }, tag: 'json:"active"' },
+    },
+  )
+}
+
+describe('encoding/json override', () => {
+  it('marshals struct fields through json tags', () => {
+    const person = new Person()
+    person._fields.Name.value = 'Alice'
+    person._fields.Age.value = 30
+    person._fields.Active.value = true
+
+    const [data, err] = Marshal(person)
+
+    expect(err).toBeNull()
+    expect($.bytesToString(data)).toBe(
+      '{"name":"Alice","age":30,"active":true}',
+    )
+  })
+
+  it('unmarshals into struct and map pointers', () => {
+    const person = $.varRef(new Person())
+    const personErr = Unmarshal(
+      $.stringToBytes('{"name":"Bob","age":25,"active":false}'),
+      person,
+    )
+
+    expect(personErr).toBeNull()
+    expect(person.value._fields.Name.value).toBe('Bob')
+    expect(person.value._fields.Age.value).toBe(25)
+    expect(person.value._fields.Active.value).toBe(false)
+
+    const mapRef: $.VarRef<Map<string, unknown> | null> = $.varRef(null)
+    const mapErr = Unmarshal(
+      $.stringToBytes('{"name":"Carol","age":22,"active":true}'),
+      mapRef,
+    )
+
+    expect(mapErr).toBeNull()
+    expect(mapRef.value?.get('name')).toBe('Carol')
+    expect(mapRef.value?.get('age')).toBe(22)
+    expect(mapRef.value?.get('active')).toBe(true)
+  })
+})

package/gs/encoding/json/index.ts

@@ -0,0 +1,186 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export function Marshal(v: unknown): [$.Slice<number>, $.GoError] {
+  try {
+    return [$.stringToBytes(JSON.stringify(marshalValue(v))), null]
+  } catch (err) {
+    return [null, goError(err)]
+  }
+}
+
+export function Unmarshal(data: $.Slice<number>, v: unknown): $.GoError {
+  try {
+    assignDecodedValue(v, JSON.parse($.bytesToString(data)))
+    return null
+  } catch (err) {
+    return goError(err)
+  }
+}
+
+function marshalValue(v: unknown): unknown {
+  if ($.isVarRef(v)) {
+    return marshalValue(v.value)
+  }
+  if (v === null || v === undefined) {
+    return null
+  }
+  if (typeof v !== 'object') {
+    return v
+  }
+  if (v instanceof Uint8Array) {
+    return Array.from(v).map(marshalValue)
+  }
+  if (Array.isArray(v)) {
+    return v.map(marshalValue)
+  }
+  if (v instanceof Map) {
+    const out: Record<string, unknown> = {}
+    for (const [key, value] of v.entries()) {
+      out[String(key)] = marshalValue(value)
+    }
+    return out
+  }
+  if (!isStructValue(v)) {
+    return v
+  }
+
+  const out: Record<string, unknown> = {}
+  const typeFields = structFieldMetadata(v)
+  for (const [fieldName, ref] of Object.entries(v._fields)) {
+    const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag)
+    if (jsonName === '') {
+      continue
+    }
+    out[jsonName] = marshalValue(ref.value)
+  }
+  return out
+}
+
+function assignDecodedValue(target: unknown, decoded: unknown): void {
+  if ($.isVarRef(target)) {
+    if (isStructValue(target.value) && isPlainObject(decoded)) {
+      assignStructFields(target.value, decoded)
+      return
+    }
+    if (isPlainObject(decoded)) {
+      target.value = objectToMap(decoded)
+      return
+    }
+    target.value = decoded
+    return
+  }
+  if (isStructValue(target) && isPlainObject(decoded)) {
+    assignStructFields(target, decoded)
+  }
+}
+
+function assignStructFields(
+  target: { _fields: Record<string, $.VarRef<unknown>> },
+  decoded: Record<string, unknown>,
+): void {
+  const typeFields = structFieldMetadata(target)
+  for (const [fieldName, ref] of Object.entries(target._fields)) {
+    const jsonName = jsonFieldName(fieldName, typeFields[fieldName]?.tag)
+    if (
+      jsonName !== '' &&
+      Object.prototype.hasOwnProperty.call(decoded, jsonName)
+    ) {
+      ref.value = decoded[jsonName]
+    }
+  }
+}
+
+function objectToMap(decoded: Record<string, unknown>): Map<string, unknown> {
+  const out = new Map<string, unknown>()
+  for (const [key, value] of Object.entries(decoded)) {
+    out.set(key, isPlainObject(value) ? objectToMap(value) : value)
+  }
+  return out
+}
+
+function isStructValue(
+  value: unknown,
+): value is { _fields: Record<string, $.VarRef<unknown>> } {
+  if (value === null || typeof value !== 'object') {
+    return false
+  }
+  const fields = Reflect.get(value, '_fields')
+  return (
+    fields !== null &&
+    fields !== undefined &&
+    typeof fields === 'object' &&
+    !Array.isArray(fields)
+  )
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    !(value instanceof Uint8Array) &&
+    !(value instanceof Map)
+  )
+}
+
+function structFieldMetadata(
+  value: unknown,
+): Record<string, { tag?: string }> {
+  if (value === null || typeof value !== 'object') {
+    return {}
+  }
+  const ctor = Reflect.get(value, 'constructor')
+  if (
+    ctor === null ||
+    ctor === undefined ||
+    (typeof ctor !== 'object' && typeof ctor !== 'function')
+  ) {
+    return {}
+  }
+  const typeInfo = Reflect.get(ctor, '__typeInfo')
+  if (
+    typeInfo === null ||
+    typeInfo === undefined ||
+    typeof typeInfo !== 'object'
+  ) {
+    return {}
+  }
+  const fields = Reflect.get(typeInfo, 'fields')
+  if (isPlainObject(fields)) {
+    const out: Record<string, { tag?: string }> = {}
+    for (const [name, field] of Object.entries(fields)) {
+      if (!isPlainObject(field)) {
+        continue
+      }
+      const tag = field.tag
+      out[name] = typeof tag === 'string' ? { tag } : {}
+    }
+    return out
+  }
+  return {}
+}
+
+function goError(err: unknown): $.GoError {
+  if (err instanceof Error) {
+    return $.toGoError(err)
+  }
+  return $.newError(String(err))
+}
+
+function jsonFieldName(fieldName: string, tag: string | undefined): string {
+  if (tag === undefined || !tag.startsWith('json:"')) {
+    return fieldName
+  }
+  const end = tag.indexOf('"', 'json:"'.length)
+  if (end < 0) {
+    return fieldName
+  }
+  const name = tag.slice('json:"'.length, end).split(',')[0]
+  if (name === '-') {
+    return ''
+  }
+  if (name === '') {
+    return fieldName
+  }
+  return name
+}