goscript 0.1.0 → 0.1.2

package/gs/reflect/typefor.test.ts

@@ -1,12 +1,29 @@
 import { describe, it, expect } from 'vitest'
 import {
+  makeMap,
+  mapGet,
+  mapSet,
   TypeKind,
   registerInterfaceType,
   registerStructType,
 } from '../builtin/index.js'
+import { StructField } from './types.js'
 import { Int, Struct, TypeFor } from './type.js'
 
 describe('TypeFor', () => {
+  it('exposes StructField PkgPath and exported semantics', () => {
+    const exported = new StructField({ Name: 'Field' })
+    const unexported = new StructField({
+      Name: 'field',
+      PkgPath: 'example.test/pkg',
+    })
+
+    expect(exported.PkgPath).toBe('')
+    expect(exported.IsExported()).toBe(true)
+    expect(unexported.IsExported()).toBe(false)
+    expect(unexported.clone().PkgPath).toBe('example.test/pkg')
+  })
+
   it('uses generic runtime type descriptors', () => {
     const intType = TypeFor({
       T: {
@@ -17,6 +34,18 @@ describe('TypeFor', () => {
 
     expect(intType.String()).toBe('int')
     expect(intType.Kind()).toBe(Int)
+    expect(intType.PkgPath()).toBe('')
+
+    const namedIntType = TypeFor({
+      T: {
+        type: { kind: TypeKind.Basic, name: 'int', typeName: 'gob.typeId' },
+        zero: () => 0,
+      },
+    })
+    expect(namedIntType.String()).toBe('gob.typeId')
+    expect(namedIntType.Name()).toBe('typeId')
+    expect(namedIntType.PkgPath()).toBe('gob')
+    expect(namedIntType.Kind()).toBe(Int)
   })
 
   it('formats literal interface methods from type metadata', () => {
@@ -50,6 +79,7 @@ describe('TypeFor', () => {
 
   it('resolves registered type names from descriptors', () => {
     class RegisteredStruct {}
+    class RegisteredWithFields {}
     registerStructType(
       'main.RegisteredStruct',
       new RegisteredStruct(),
@@ -57,6 +87,24 @@ describe('TypeFor', () => {
       RegisteredStruct,
       {},
     )
+    registerStructType(
+      'main.RegisteredWithFields',
+      new RegisteredWithFields(),
+      [],
+      RegisteredWithFields,
+      {
+        Name: { kind: TypeKind.Basic, name: 'string' },
+        Count: {
+          name: 'Total',
+          type: { kind: TypeKind.Basic, name: 'int' },
+          tag: 'json:"total"',
+        },
+        Items: {
+          kind: TypeKind.Slice,
+          elemType: 'main.RegisteredStruct',
+        },
+      },
+    )
     registerInterfaceType('main.RegisteredInterface', null, [
       { name: 'SomeMethod', args: [], returns: [] },
     ])
@@ -71,5 +119,57 @@ describe('TypeFor', () => {
     expect(structType.String()).toBe('main.RegisteredStruct')
     expect(structType.Kind()).toBe(Struct)
     expect(ifaceType.String()).toBe('interface { SomeMethod() }')
+
+    const fieldsType = TypeFor({
+      T: {
+        type: 'main.RegisteredWithFields',
+        zero: () => new RegisteredWithFields(),
+      },
+    })
+    expect(fieldsType.NumField()).toBe(3)
+    expect(fieldsType.Field(0).Name).toBe('Name')
+    expect(fieldsType.Field(0).Type.String()).toBe('string')
+    expect(fieldsType.Field(1).Name).toBe('Total')
+    expect(fieldsType.Field(1).Tag.Get('json')).toBe('total')
+    expect(fieldsType.Field(2).Type.String()).toBe('[]main.RegisteredStruct')
+    expect(fieldsType.Field(2).Type.Elem().String()).toBe('main.RegisteredStruct')
+  })
+
+  it('interns runtime type descriptors for reflect.Type map keys', () => {
+    const first = TypeFor({
+      T: { type: 'gob.wireType', zero: () => ({}) },
+    })
+    const second = TypeFor({
+      T: { type: 'gob.wireType', zero: () => ({}) },
+    })
+    const arrayType = TypeFor({
+      T: {
+        type: {
+          kind: TypeKind.Array,
+          elemType: { kind: TypeKind.Basic, name: 'uint8' },
+          length: 16,
+        },
+        zero: () => new Uint8Array(16),
+      },
+    })
+
+    expect(second).toBe(first)
+    expect(arrayType).toBe(
+      TypeFor({
+        T: {
+          type: {
+            kind: TypeKind.Array,
+            elemType: { kind: TypeKind.Basic, name: 'uint8' },
+            length: 16,
+          },
+          zero: () => new Uint8Array(16),
+        },
+      }),
+    )
+
+    const m = makeMap<typeof first, string>()
+    mapSet(m, first, 'wire')
+
+    expect(mapGet(m, second, '')).toEqual(['wire', true])
   })
 })

package/gs/reflect/types.ts

@@ -40,6 +40,7 @@ import { Type, Kind, Value, Kind_String, ChanDir } from './type.js'
 // Struct field representation
 export class StructField {
   public Name: string = ''
+  public PkgPath: string = ''
   public Type!: Type
   public Tag: StructTag = new StructTag('')
   public Offset: uintptr = 0
@@ -55,6 +56,7 @@ export class StructField {
   public clone(): StructField {
     return new StructField({
       Name: this.Name,
+      PkgPath: this.PkgPath,
       Type: this.Type,
       Tag: this.Tag,
       Offset: this.Offset,
@@ -64,7 +66,7 @@ export class StructField {
   }
 
   public IsExported(): boolean {
-    return this.Name !== '' && this.Name[0] !== '_'
+    return this.PkgPath === ''
   }
 }
 

package/gs/reflect/value.ts

@@ -26,7 +26,13 @@ import {
   BasicType,
   Invalid,
 } from './type.js'
-import { ReflectValue, SelectCase, SelectRecv, SelectDefault } from './types.js'
+import {
+  Pointer,
+  ReflectValue,
+  SelectCase,
+  SelectRecv,
+  SelectDefault,
+} from './types.js'
 
 interface ChannelObject {
   _sendQueue?: unknown[]
@@ -142,6 +148,33 @@ export function New(typ: Type | null): Value {
   return new Value(null, ptrType) // null represents the pointer value
 }
 
+// NewAt returns a Value representing a pointer to the value at p.
+export function NewAt(typ: Type | null, p: Pointer | unknown): Value {
+  if (typ === null) {
+    return new Value()
+  }
+  const ptrType = PointerTo(typ)
+  if (
+    p &&
+    typeof p === 'object' &&
+    'value' in p &&
+    (p as { value?: unknown }).value instanceof Value
+  ) {
+    const target = (p as { value: Value }).value
+    const ref: $.VarRef<ReflectValue> = {
+      get value(): ReflectValue {
+        return target.Interface() as ReflectValue
+      },
+      set value(value: ReflectValue) {
+        target.Set(new Value(value, typ))
+      },
+      __isVarRef: true,
+    }
+    return new Value(ref, ptrType)
+  }
+  return new Value($.unsupportedPointerRef<ReflectValue>(p), ptrType)
+}
+
 // MakeSlice returns a Value representing a new slice with the specified type, length, and capacity.
 export function MakeSlice(typ: Type | null, len: number, _cap: number): Value {
   if (typ === null || typ.Kind() !== Slice) {
@@ -171,6 +204,10 @@ export function MakeMap(typ: Type | null): Value {
   return new Value(map, typ)
 }
 
+export function MakeMapWithSize(typ: Type | null, _n: number): Value {
+  return MakeMap(typ)
+}
+
 // Append appends the values x to a slice and returns the resulting slice.
 export function Append(s: Value, x: Value): Value {
   if (s.Kind() !== Slice) {
@@ -188,6 +225,18 @@ export function Append(s: Value, x: Value): Value {
   return new Value(newArray, s.Type())
 }
 
+export function AppendSlice(s: Value, t: Value): Value {
+  if (s.Kind() !== Slice || t.Kind() !== Slice) {
+    throw new Error('reflect.AppendSlice of non-slice')
+  }
+  const left = getArrayFromValue(s)
+  const right = getArrayFromValue(t)
+  if (!left || !right) {
+    throw new Error('cannot get array from slice value')
+  }
+  return new Value([...left, ...right], s.Type())
+}
+
 // MakeChan returns a Value representing a new channel with the specified type.
 export function MakeChan(typ: Type, buffer: number): Value {
   if (typ.Kind() !== Chan) {

package/gs/reflect/visiblefields.ts

@@ -131,7 +131,7 @@ class visibleFieldsWalker {
       const field = t!.Field(i)
       if (field) {
         const f = field.clone()
-        f.Index = $.append(null, w.index) as number[]
+        f.Index = $.append(null, ...(w.index ?? [])) as number[]
         if (f.Anonymous) {
           if (f.Type && f.Type.Kind() === Ptr) {
             const elemType = f.Type.Elem!()

package/gs/runtime/debug/index.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it, vi } from 'vitest'
+
+import { BuildInfo, BuildSetting, Module, PrintStack, ReadBuildInfo, Stack } from './index.js'
+
+describe('runtime/debug override', () => {
+  it('returns a stack trace as bytes', () => {
+    const stack = Stack()
+
+    expect(stack).toBeInstanceOf(Uint8Array)
+    expect(new TextDecoder().decode(stack)).toContain('Error')
+  })
+
+  it('prints the current stack trace', () => {
+    const consoleError = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+    try {
+      PrintStack()
+      expect(consoleError).toHaveBeenCalledTimes(1)
+      expect(consoleError.mock.calls[0][0]).toContain('Error')
+    } finally {
+      consoleError.mockRestore()
+    }
+  })
+
+  it('exposes build info structs and reports no embedded module table', () => {
+    const module = new Module({
+      Path: 'example.test/module',
+      Version: 'v1.2.3',
+      Sum: 'h1:sum',
+      Replace: new Module({ Path: '../module' }),
+    })
+    const info = new BuildInfo({
+      GoVersion: 'go1.26.3',
+      Path: 'example.test/main',
+      Main: module,
+      Deps: [module],
+      Settings: [new BuildSetting({ Key: 'GOOS', Value: 'js' })],
+    })
+
+    expect(info.Main.Path).toBe('example.test/module')
+    expect(info.Deps?.[0]).toBe(module)
+    expect(info.Settings?.[0]?.Value).toBe('js')
+    expect(ReadBuildInfo()).toEqual([null, false])
+  })
+})

package/gs/runtime/debug/index.ts

@@ -0,0 +1,96 @@
+import * as $ from '@goscript/builtin/index.js'
+
+export class BuildSetting {
+  public Key: string
+  public Value: string
+
+  constructor(init?: Partial<{ Key: string; Value: string }>) {
+    this.Key = init?.Key ?? ''
+    this.Value = init?.Value ?? ''
+  }
+
+  public clone(): BuildSetting {
+    return $.markAsStructValue(new BuildSetting({ Key: this.Key, Value: this.Value }))
+  }
+}
+
+export class Module {
+  public Path: string
+  public Version: string
+  public Sum: string
+  public Replace: Module | $.VarRef<Module> | null
+
+  constructor(
+    init?: Partial<{
+      Path: string
+      Version: string
+      Sum: string
+      Replace: Module | $.VarRef<Module> | null
+    }>,
+  ) {
+    this.Path = init?.Path ?? ''
+    this.Version = init?.Version ?? ''
+    this.Sum = init?.Sum ?? ''
+    this.Replace = init?.Replace ?? null
+  }
+
+  public clone(): Module {
+    return $.markAsStructValue(
+      new Module({
+        Path: this.Path,
+        Version: this.Version,
+        Sum: this.Sum,
+        Replace: this.Replace,
+      }),
+    )
+  }
+}
+
+export class BuildInfo {
+  public GoVersion: string
+  public Path: string
+  public Main: Module
+  public Deps: $.Slice<Module | $.VarRef<Module> | null>
+  public Settings: $.Slice<BuildSetting>
+
+  constructor(
+    init?: Partial<{
+      GoVersion: string
+      Path: string
+      Main: Module
+      Deps: $.Slice<Module | $.VarRef<Module> | null>
+      Settings: $.Slice<BuildSetting>
+    }>,
+  ) {
+    this.GoVersion = init?.GoVersion ?? ''
+    this.Path = init?.Path ?? ''
+    this.Main = init?.Main ?? new Module()
+    this.Deps = init?.Deps ?? null
+    this.Settings = init?.Settings ?? null
+  }
+
+  public clone(): BuildInfo {
+    return $.markAsStructValue(
+      new BuildInfo({
+        GoVersion: this.GoVersion,
+        Path: this.Path,
+        Main: this.Main.clone(),
+        Deps: this.Deps,
+        Settings: this.Settings,
+      }),
+    )
+  }
+}
+
+export function Stack(): Uint8Array {
+  const stack = new Error().stack ?? 'stack trace unavailable'
+  return new TextEncoder().encode(stack)
+}
+
+export function PrintStack(): void {
+  console.error(new TextDecoder().decode(Stack()))
+}
+
+export function ReadBuildInfo(): [BuildInfo | null, boolean] {
+  return [null, false]
+}

package/gs/runtime/pprof/index.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest'
+
+import { Lookup, StartCPUProfile, StopCPUProfile } from './index.js'
+
+describe('runtime/pprof override', () => {
+  it('writes deterministic CPU profile bytes', () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(new Uint8Array(p))
+        return [p.length, null]
+      },
+    }
+
+    expect(StartCPUProfile(writer)).toBeNull()
+    StopCPUProfile()
+
+    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+  })
+
+  it('writes deterministic memory profile bytes', () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(new Uint8Array(p))
+        return [p.length, null]
+      },
+    }
+
+    const profile = Lookup('allocs')
+
+    expect(profile).not.toBeNull()
+    expect(profile!.WriteTo(writer, 0)).toBeNull()
+    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+  })
+})

package/gs/runtime/pprof/index.ts

@@ -0,0 +1,104 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+type WriterArg = io.Writer | $.VarRef<io.Writer> | null | undefined
+
+let activeCPUWriter: io.Writer | null = null
+
+export class Profile {
+  public name: string
+
+  constructor(name = '') {
+    this.name = name
+  }
+
+  public Name(): string {
+    return this.name
+  }
+
+  public Count(): number {
+    return this.name === '' ? 0 : 1
+  }
+
+  public WriteTo(w: WriterArg, debug: number): $.GoError {
+    return writeProfile(w, `goscript pprof ${this.name} debug=${debug}\n`)
+  }
+}
+
+export function Lookup(name: string): Profile | null {
+  switch (name) {
+    case 'heap':
+    case 'allocs':
+    case 'goroutine':
+    case 'threadcreate':
+    case 'block':
+    case 'mutex':
+      return new Profile(name)
+    default:
+      return null
+  }
+}
+
+export function Profiles(): $.Slice<Profile | null> {
+  return $.arrayToSlice([
+    new Profile('allocs'),
+    new Profile('block'),
+    new Profile('goroutine'),
+    new Profile('heap'),
+    new Profile('mutex'),
+    new Profile('threadcreate'),
+  ])
+}
+
+export function StartCPUProfile(w: WriterArg): $.GoError {
+  const writer = writerFromArg(w)
+  if (writer == null) {
+    return errors.New('runtime/pprof: nil profile writer')
+  }
+  if (activeCPUWriter != null) {
+    return errors.New('runtime/pprof: CPU profiling already active')
+  }
+  activeCPUWriter = writer
+  return writeProfile(writer, 'goscript cpu profile start\n')
+}
+
+export function StopCPUProfile(): void {
+  if (activeCPUWriter != null) {
+    writeProfile(activeCPUWriter, 'goscript cpu profile stop\n')
+    activeCPUWriter = null
+  }
+}
+
+export function SetGoroutineLabels(_ctx: unknown): void {}
+
+export function Do(_ctx: unknown, _labels: unknown, fn: (() => void) | null): void {
+  fn?.()
+}
+
+export function ForLabels(_ctx: unknown, _f: unknown): void {}
+
+export function WithLabels(ctx: unknown, _labels: unknown): unknown {
+  return ctx
+}
+
+export function Labels(...args: string[]): Map<string, string> {
+  const labels = new Map<string, string>()
+  for (let i = 0; i + 1 < args.length; i += 2) {
+    labels.set(args[i], args[i + 1])
+  }
+  return labels
+}
+
+function writerFromArg(w: WriterArg): io.Writer | null {
+  return $.pointerValueOrNil(w)
+}
+
+function writeProfile(w: WriterArg, text: string): $.GoError {
+  const writer = writerFromArg(w)
+  if (writer == null) {
+    return errors.New('runtime/pprof: nil profile writer')
+  }
+  const [, err] = writer.Write($.stringToBytes(text))
+  return err
+}

package/gs/runtime/pprof/meta.json

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

package/gs/runtime/runtime.test.ts

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+
+import {
+  Compiler,
+  FuncForPC,
+  ReadTrace,
+  StartTrace,
+  StopTrace,
+} from './runtime.js'
+
+describe('runtime override', () => {
+  it('exposes stack and trace compatibility helpers', () => {
+    expect(Compiler).toBe('gc')
+    expect(FuncForPC(0)).toBeNull()
+    expect(StartTrace()).toBeNull()
+    expect(ReadTrace()).toBeNull()
+    expect(() => StopTrace()).not.toThrow()
+  })
+})

package/gs/runtime/runtime.ts

@@ -1,9 +1,12 @@
+import * as $ from '@goscript/builtin/index.js'
+
 // Runtime constants for the JavaScript/WebAssembly target
-export const GOOS = 'js'
-export const GOARCH = 'wasm'
+export const GOOS: string = 'js'
+export const GOARCH: string = 'wasm'
+export const Compiler: string = 'gc'
 
 // Version returns the Go version as a string
-export const GOVERSION = 'go1.25.3'
+export const GOVERSION: string = 'go1.25.3'
 export function Version(): string {
   return GOVERSION
 }
@@ -79,6 +82,79 @@ export function Caller(_skip: number): [number, string, number, boolean] {
   return [pc, file, line, ok]
 }
 
+// Func represents metadata for a function in a stack frame.
+export class Func {
+  public Entry(): number {
+    return 0
+  }
+
+  public FileLine(_pc: number): [string, number] {
+    return ['', 0]
+  }
+
+  public Name(): string {
+    return ''
+  }
+}
+
+// FuncForPC returns function metadata for a program counter.
+export function FuncForPC(_pc: number): Func | null {
+  return null
+}
+
+// StartTrace enables execution tracing.
+export function StartTrace(): $.GoError {
+  return null
+}
+
+// StopTrace stops execution tracing.
+export function StopTrace(): void {}
+
+// ReadTrace returns the next execution trace chunk.
+export function ReadTrace(): $.Slice<number> {
+  return null
+}
+
+// Frame represents a single call frame.
+export class Frame {
+  public PC = 0
+  public Func: Func | null = null
+  public Function = ''
+  public File = ''
+  public Line = 0
+  public Entry = 0
+}
+
+// Frames iterates over call frames.
+export class Frames {
+  private readonly frames: Frame[]
+  private index = 0
+
+  constructor(frames: Frame[] = []) {
+    this.frames = frames
+  }
+
+  public Next(): [Frame, boolean] {
+    if (this.index >= this.frames.length) {
+      return [new Frame(), false]
+    }
+
+    const frame = this.frames[this.index]
+    this.index++
+    return [frame, this.index < this.frames.length]
+  }
+}
+
+// Callers fills pc with return program counters from the current stack.
+export function Callers(_skip: number, _pc: $.Slice<number>): number {
+  return 0
+}
+
+// CallersFrames returns an iterator over call frames for pcs.
+export function CallersFrames(_callers: $.Slice<number>): Frames {
+  return new Frames()
+}
+
 // Stack returns a formatted stack trace of the calling goroutine.
 // In JavaScript, we use Error.stack
 export function Stack(): Uint8Array {
@@ -167,6 +243,25 @@ export function SetFinalizer(
   )
 }
 
+// Cleanup is a handle to a cleanup call for a specific object.
+export class Cleanup {
+  public Stop(): void {}
+
+  public clone(): Cleanup {
+    return new Cleanup()
+  }
+}
+
+// AddCleanup registers cleanup to run when ptr is no longer reachable.
+export function AddCleanup<T, S>(
+  _ptr: T,
+  _cleanup: (arg: S) => void | Promise<void>,
+  _arg: S,
+): Cleanup {
+  // JavaScript runtimes do not provide Go's cleanup scheduling contract here.
+  return new Cleanup()
+}
+
 // KeepAlive keeps obj reachable until the point where KeepAlive is called
 export function KeepAlive(obj: any): void {
   // In JavaScript, just accessing the object keeps it alive for this call