goscript 0.0.84 → 0.1.1

package/gs/builtin/hostio.ts

@@ -29,19 +29,29 @@ export type NodeFSModule = {
   lchownSync?(path: string, uid: number, gid: number): void
   linkSync?(existingPath: string, newPath: string): void
   lstatSync?(path: string): any
-  mkdirSync?(path: string, options?: number | { mode?: number; recursive?: boolean }): void
+  mkdirSync?(
+    path: string,
+    options?: number | { mode?: number; recursive?: boolean },
+  ): void
   readFileSync?(path: string): Uint8Array
   readdirSync?(path: string, options?: { withFileTypes?: boolean }): any[]
   readlinkSync?(path: string): string
   renameSync?(oldPath: string, newPath: string): void
-  rmSync?(path: string, options?: { force?: boolean; recursive?: boolean }): void
+  rmSync?(
+    path: string,
+    options?: { force?: boolean; recursive?: boolean },
+  ): void
   rmdirSync?(path: string): void
   statSync?(path: string): any
   symlinkSync?(target: string, path: string): void
   truncateSync?(path: string, len?: number): void
   unlinkSync?(path: string): void
   utimesSync?(path: string, atime: Date | number, mtime: Date | number): void
-  writeFileSync?(path: string, data: Uint8Array, options?: { mode?: number }): void
+  writeFileSync?(
+    path: string,
+    data: Uint8Array,
+    options?: { mode?: number },
+  ): void
 }
 
 export type DenoStream = {
@@ -75,6 +85,13 @@ export type HostRuntime = {
   writeStdoutText: HostTextWrite
 }
 
+export type HostRuntimeDetector = () => HostRuntime
+
+export type MainScriptMeta = {
+  url: string
+  main?: boolean
+}
+
 const encoder = new TextEncoder()
 
 function getDynamicRequire(): ((specifier: string) => unknown) | null {
@@ -149,12 +166,66 @@ function detectNodeFS(processObj: any | null): NodeFSModule | null {
   return null
 }
 
-function unsupportedReadFD(_fd: number, _buffer: Uint8Array): number | null {
-  throw new HostUnsupportedError()
+function hasURLScheme(path: string): boolean {
+  return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(path)
+}
+
+function isAbsoluteScriptPath(path: string): boolean {
+  return path.startsWith('/') || /^[A-Za-z]:[\\/]/.test(path)
+}
+
+function normalizePath(path: string): string {
+  return path.replace(/\\/g, '/')
+}
+
+function absolutePathToFileURL(path: string, isDirectory: boolean): string {
+  const normalized = normalizePath(path)
+  const suffix = isDirectory && !normalized.endsWith('/') ? '/' : ''
+  if (/^[A-Za-z]:\//.test(normalized)) {
+    return new URL(`file:///${normalized}${suffix}`).href
+  }
+  return new URL(`file://${normalized}${suffix}`).href
+}
+
+function getCurrentWorkingDirectory(): string | null {
+  const runtime = getHostRuntime()
+  try {
+    if (typeof runtime.processObj?.cwd === 'function') {
+      return runtime.processObj.cwd()
+    }
+  } catch {
+    // Fall through to Deno cwd.
+  }
+
+  try {
+    if (typeof runtime.deno?.cwd === 'function') {
+      return runtime.deno.cwd()
+    }
+  } catch {
+    // No cwd fallback available.
+  }
+
+  return null
 }
 
-function unsupportedWriteFD(_fd: number, _buffer: Uint8Array): number {
-  throw new HostUnsupportedError()
+function fileURLFromScriptPath(path: string): string | null {
+  try {
+    if (hasURLScheme(path)) {
+      return new URL(path).href
+    }
+
+    if (isAbsoluteScriptPath(path)) {
+      return absolutePathToFileURL(path, false)
+    }
+
+    const cwd = getCurrentWorkingDirectory()
+    if (!cwd) {
+      return null
+    }
+    return new URL(normalizePath(path), absolutePathToFileURL(cwd, true)).href
+  } catch {
+    return null
+  }
 }
 
 function fallbackConsoleWriter(method: 'error' | 'log'): HostTextWrite {
@@ -193,10 +264,7 @@ function detectHostRuntime(): HostRuntime {
     }
   }
 
-  const platform =
-    deno?.build?.os ??
-    processObj?.platform ??
-    'unknown'
+  const platform = deno?.build?.os ?? processObj?.platform ?? 'unknown'
 
   const getEnv = (name: string): string => {
     if (deno?.env?.get) {
@@ -209,64 +277,67 @@ function detectHostRuntime(): HostRuntime {
     return processObj?.env?.[name] ?? ''
   }
 
-  let readFD: HostReadFD = unsupportedReadFD
-  let writeFD: HostWriteFD = unsupportedWriteFD
-  let writeStdoutText: HostTextWrite = fallbackConsoleWriter('log')
-  let writeStderrText: HostTextWrite = fallbackConsoleWriter('error')
-
-  if (deno) {
-    readFD = (fd: number, buffer: Uint8Array): number | null => {
-      const handle = getStdioHandle(fd)
-      if (!handle || typeof handle.readSync !== 'function') {
-        throw new HostUnsupportedError()
-      }
+  const readFD: HostReadFD = (
+    fd: number,
+    buffer: Uint8Array,
+  ): number | null => {
+    const handle = getStdioHandle(fd)
+    if (handle && typeof handle.readSync === 'function') {
       return handle.readSync(buffer)
     }
-    writeFD = (fd: number, buffer: Uint8Array): number => {
-      const handle = getStdioHandle(fd)
-      if (!handle || typeof handle.writeSync !== 'function') {
-        throw new HostUnsupportedError()
-      }
+    if (nodeFS) {
+      return nodeFS.readSync(fd, buffer, 0, buffer.length, null)
+    }
+    throw new HostUnsupportedError()
+  }
+  const writeFD: HostWriteFD = (fd: number, buffer: Uint8Array): number => {
+    const handle = getStdioHandle(fd)
+    if (handle && typeof handle.writeSync === 'function') {
       return writeAllSync(
         (chunk: Uint8Array) => handle.writeSync!(chunk),
         buffer,
       )
     }
-    writeStdoutText = (data: string) => {
-      const handle = getStdioHandle(1)
-      if (!handle || typeof handle.writeSync !== 'function') {
-        fallbackConsoleWriter('log')(data)
-        return
-      }
-      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
-    }
-    writeStderrText = (data: string) => {
-      const handle = getStdioHandle(2)
-      if (!handle || typeof handle.writeSync !== 'function') {
-        fallbackConsoleWriter('error')(data)
-        return
-      }
-      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
-    }
-  } else if (nodeFS) {
-    readFD = (fd: number, buffer: Uint8Array): number | null =>
-      nodeFS.readSync(fd, buffer, 0, buffer.length, null)
-    writeFD = (fd: number, buffer: Uint8Array): number =>
-      writeAllSync(
+    if (nodeFS) {
+      return writeAllSync(
         (chunk: Uint8Array) =>
           nodeFS.writeSync(fd, chunk, 0, chunk.length, null),
         buffer,
       )
-    writeStdoutText = (data: string) =>
+    }
+    throw new HostUnsupportedError()
+  }
+  const writeStdoutText: HostTextWrite = (data: string) => {
+    const handle = getStdioHandle(1)
+    if (handle && typeof handle.writeSync === 'function') {
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+      return
+    }
+    if (nodeFS) {
       writeAllText(
-        (chunk: Uint8Array) => nodeFS.writeSync(1, chunk, 0, chunk.length, null),
+        (chunk: Uint8Array) =>
+          nodeFS.writeSync(1, chunk, 0, chunk.length, null),
         data,
       )
-    writeStderrText = (data: string) =>
+      return
+    }
+    fallbackConsoleWriter('log')(data)
+  }
+  const writeStderrText: HostTextWrite = (data: string) => {
+    const handle = getStdioHandle(2)
+    if (handle && typeof handle.writeSync === 'function') {
+      writeAllText((chunk: Uint8Array) => handle.writeSync!(chunk), data)
+      return
+    }
+    if (nodeFS) {
       writeAllText(
-        (chunk: Uint8Array) => nodeFS.writeSync(2, chunk, 0, chunk.length, null),
+        (chunk: Uint8Array) =>
+          nodeFS.writeSync(2, chunk, 0, chunk.length, null),
         data,
       )
+      return
+    }
+    fallbackConsoleWriter('error')(data)
   }
 
   return {
@@ -283,16 +354,60 @@ function detectHostRuntime(): HostRuntime {
   }
 }
 
-export let hostRuntime = detectHostRuntime()
+export class HostRuntimeOwner {
+  private runtime: HostRuntime
+
+  constructor(
+    private readonly detector: HostRuntimeDetector = detectHostRuntime,
+  ) {
+    this.runtime = detector()
+  }
+
+  current(): HostRuntime {
+    return this.runtime
+  }
+
+  reset(): void {
+    this.runtime = this.detector()
+  }
+}
+
+export const hostRuntimeOwner = new HostRuntimeOwner()
+
+export function getHostRuntime(): HostRuntime {
+  return hostRuntimeOwner.current()
+}
 
 export function resetHostRuntimeForTests(): void {
-  hostRuntime = detectHostRuntime()
+  hostRuntimeOwner.reset()
 }
 
 export function writeHostStdoutText(data: string): void {
-  hostRuntime.writeStdoutText(data)
+  getHostRuntime().writeStdoutText(data)
 }
 
 export function writeHostStderrText(data: string): void {
-  hostRuntime.writeStderrText(data)
+  getHostRuntime().writeStderrText(data)
+}
+
+export function isMainScript(meta: MainScriptMeta): boolean {
+  if (meta.main === true) {
+    return true
+  }
+
+  const entryPath = getHostRuntime().processObj?.argv?.[1]
+  if (typeof entryPath !== 'string' || entryPath === '') {
+    return false
+  }
+
+  const entryURL = fileURLFromScriptPath(entryPath)
+  if (!entryURL) {
+    return false
+  }
+
+  try {
+    return new URL(meta.url).href === entryURL
+  } catch {
+    return meta.url === entryURL
+  }
 }

package/gs/builtin/index.ts

@@ -6,3 +6,4 @@ export * from './type.js'
 export * from './varRef.js'
 export * from './defer.js'
 export * from './errors.js'
+export * from './hostio.js'

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

@@ -0,0 +1,356 @@
+import { afterEach, describe, expect, it, vi } from 'vitest'
+
+import {
+  bytesToUint8Array,
+  byte,
+  cap,
+  cloneStructValue,
+  callGenericMethod,
+  chanRecvWithOk,
+  functionValue,
+  genericZero,
+  goSlice,
+  int,
+  indexAddress,
+  indexRef,
+  interfaceValue,
+  len,
+  makeSlice,
+  makeChannel,
+  makeMap,
+  mapGet,
+  mapSet,
+  markAsStructValue,
+  namedFunction,
+  newError,
+  pointerValue,
+  print,
+  println,
+  rangeString,
+  registerInterfaceType,
+  registerStructType,
+  resetHostRuntimeForTests,
+  sliceToArray,
+  TypeKind,
+  typeAssert,
+  typedNil,
+  uint,
+  uint64Add,
+  uint64And,
+  uint64Mul,
+  uint64Or,
+  uint64Shl,
+  uint64Shr,
+  uint64Sub,
+  uint64Xor,
+  uintShr,
+  unref,
+  unsupportedPointerRef,
+  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(int(3n)).toBe(3)
+    expect(uint(-1n, 8)).toBe(255)
+    expect(byte(257)).toBe(1)
+    expect(uint(uint64Shl(1n, 63), 32)).toBe(0)
+    expect(uint(uint64Shr(uint64Shl(1n, 63), 60), 32)).toBe(8)
+    expect(uint(uint64Mul(0xffffffffffffffffn, 3), 32)).toBe(0xfffffffd)
+    expect(uint(uint64Add(0xffffffffffffffffn, 2), 32)).toBe(1)
+    expect(uint(uint64Sub(1n, 2), 32)).toBe(0xffffffff)
+    expect(uint(uint64And(0xf0n, 0x3cn), 32)).toBe(0x30)
+    expect(uint(uint64Or(0xf0n, 0x0fn), 32)).toBe(0xff)
+    expect(uint(uint64Xor(0xf0n, 0xffn), 32)).toBe(0x0f)
+    expect(uintShr(0x80000000, 31, 32)).toBe(1)
+    expect(uintShr(0x80000000, 32, 32)).toBe(0)
+    expect(uintShr(0xff, 4, 8)).toBe(15)
+
+    const value = varRef(4)
+    value.value = 8
+    expect(unref(value)).toBe(8)
+    expect(pointerValue(value)).toBe(8)
+    const pointerAssert = typeAssert<typeof value>(value, {
+      kind: TypeKind.Pointer,
+      elemType: { kind: TypeKind.Basic, name: 'int' },
+    })
+    expect(pointerAssert).toEqual({ value, ok: true })
+    const nilNamedSlice = varRef(null)
+    const nilNamedSliceIface = interfaceValue(
+      nilNamedSlice,
+      '*main.ObjectIdentifier',
+    )
+    expect(
+      typeAssert<typeof nilNamedSlice>(nilNamedSliceIface, {
+        kind: TypeKind.Pointer,
+        elemType: 'main.ObjectIdentifier',
+      }),
+    ).toEqual({ value: nilNamedSlice, ok: true })
+    expect(pointerValue({ ok: true })).toEqual({ ok: true })
+    expect(cloneStructValue({ clone: () => ({ ok: true }) })).toEqual({
+      ok: true,
+    })
+    expect(
+      cloneStructValue({ __goscriptClone: () => ({ internal: true }) }),
+    ).toEqual({ internal: true })
+    expect(() => pointerValue(null)).toThrow('nil pointer dereference')
+    const unsupported = unsupportedPointerRef<number>(0)
+    expect(() => unsupported.value).toThrow('unsafe pointer dereference')
+    expect(() => {
+      unsupported.value = 1
+    }).toThrow('unsafe 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')
+    expect(rangeString('a¢€')).toEqual([
+      [0, 97],
+      [1, 162],
+      [3, 8364],
+    ])
+  })
+
+  it('exposes addressable slice and array index references', () => {
+    const values = [1, 2, 3]
+    const second = indexRef(values, 1)
+    second.value = 8
+    expect(values).toEqual([1, 8, 3])
+    expect(pointerValue(second)).toBe(8)
+
+    const view = goSlice(values, 1, 3)
+    const firstInView = indexRef(view, 0)
+    firstInView.value = 11
+    expect(values).toEqual([1, 11, 3])
+    expect(Object.getOwnPropertyDescriptor(view, '0')?.value).toBe(11)
+
+    const bytes = new Uint8Array([4, 5])
+    const firstByte = indexRef<number>(bytes, 0)
+    firstByte.value = 9
+    expect(Array.from(bytes)).toEqual([9, 5])
+
+    const byteBacking = makeSlice<number>(8, undefined, 'byte')
+    const shortBytes = goSlice(byteBacking as Uint8Array, 0, 2)
+    expect(len(shortBytes)).toBe(2)
+    expect(cap(shortBytes)).toBe(8)
+    const fullBytes = goSlice(shortBytes, 0, 8)
+    fullBytes![7] = 12
+    expect((byteBacking as Uint8Array)[7]).toBe(12)
+
+    shortBytes![0] = 14
+    expect(bytesToUint8Array(shortBytes)).toEqual(new Uint8Array([14, 0]))
+  })
+
+  it('exposes stable synthetic slice index addresses', () => {
+    const values = [1, 2, 3, 4]
+    const left = goSlice(values, 1, 3)
+    const right = goSlice(values, 2, 4)
+    const other = [8, 9]
+
+    expect(indexAddress(left, 0)).toBe(indexAddress(values, 1))
+    expect(indexAddress(left, 1)).toBe(indexAddress(right, 0))
+    expect(indexAddress(left, 1)).toBeGreaterThan(indexAddress(left, 0))
+    expect(indexAddress(other, 0)).not.toBe(indexAddress(left, 0))
+  })
+
+  it('copies slices into fixed arrays with Go length checks', () => {
+    const source = goSlice([1, 2, 3], 1, 3)
+    const array = sliceToArray<number>(source, 2)
+    array[0] = 9
+
+    expect(array).toEqual([9, 3])
+    expect(source![0]).toBe(2)
+    expect(() => sliceToArray<number>(source, 3)).toThrow(
+      'cannot convert slice with length 2 to array with length 3',
+    )
+
+    expect(sliceToArray<number>(new Uint8Array([4, 5, 6]), 2, 'byte')).toEqual(
+      new Uint8Array([4, 5]),
+    )
+  })
+
+  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(len(channel)).toBe(1)
+    expect(await chanRecvWithOk(channel)).toEqual({ value: 7, ok: true })
+    expect(len(channel)).toBe(0)
+    channel.close()
+    expect(await chanRecvWithOk(channel)).toEqual({ value: 0, ok: false })
+  })
+})