goscript 0.1.1 → 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

@@ -1,6 +1,6 @@
 import { describe, expect, it, vi } from 'vitest'
 
-import { PrintStack, Stack } from './index.js'
+import { BuildInfo, BuildSetting, Module, PrintStack, ReadBuildInfo, Stack } from './index.js'
 
 describe('runtime/debug override', () => {
   it('returns a stack trace as bytes', () => {
@@ -21,4 +21,25 @@ describe('runtime/debug override', () => {
       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

@@ -1,3 +1,87 @@
+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)
@@ -6,3 +90,7 @@ export function Stack(): Uint8Array {
 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/trace/index.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from 'vitest'
+
+import * as context from '@goscript/context/index.js'
+
+import { IsEnabled, Log, NewTask, Start, StartRegion, Stop, WithRegion } from './index.js'
+
+describe('runtime/trace override', () => {
+  it('creates no-op tasks from nil context', () => {
+    const [ctx, task] = NewTask(null, 'task')
+
+    expect(ctx).not.toBeNull()
+    expect(task).not.toBeNull()
+    task.End()
+    Log(ctx, 'category', 'message')
+    expect(IsEnabled()).toBe(false)
+  })
+
+  it('runs no-op regions', () => {
+    const [ctx] = NewTask(context.Background(), 'task')
+    const called = { value: false }
+
+    WithRegion(ctx, 'region', () => {
+      called.value = true
+    })
+    StartRegion(ctx, 'region').End()
+
+    expect(called.value).toBe(true)
+  })
+
+  it('writes deterministic trace bytes', () => {
+    const chunks: Uint8Array[] = []
+    const writer = {
+      Write(p: Uint8Array): [number, null] {
+        chunks.push(new Uint8Array(p))
+        return [p.length, null]
+      },
+    }
+
+    expect(Start(writer)).toBeNull()
+    Log(context.Background(), 'category', 'message')
+    Stop()
+
+    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+  })
+})

package/gs/runtime/trace/index.ts

@@ -0,0 +1,97 @@
+import * as $ from '@goscript/builtin/index.js'
+import * as context from '@goscript/context/index.js'
+import * as errors from '@goscript/errors/index.js'
+import * as io from '@goscript/io/index.js'
+
+class traceContextKey {}
+
+const traceState = {
+  activeWriter: null as io.Writer | null,
+  nextTaskID: 0,
+}
+
+export class Task {
+  public id: number
+
+  constructor(id = 0) {
+    this.id = id
+  }
+
+  public End(): void {}
+}
+
+export class Region {
+  public End(): void {}
+}
+
+export function NewTask(
+  pctx: context.Context | null,
+  _taskType: string,
+): [context.Context | null, Task] {
+  const parent = pctx ?? context.Background()
+  const task = new Task(++traceState.nextTaskID)
+  return [
+    context.WithValue(
+      parent,
+      $.interfaceValue(new traceContextKey(), 'trace.traceContextKey'),
+      $.interfaceValue(task, '*trace.Task'),
+    ),
+    task,
+  ]
+}
+
+export function Log(_ctx: context.Context | null, category: string, message: string): void {
+  writeTrace(`log ${category} ${message}\n`)
+}
+
+export function Logf(
+  _ctx: context.Context | null,
+  _category: string,
+  _format: string,
+  ..._args: unknown[]
+): void {}
+
+export function WithRegion(
+  _ctx: context.Context | null,
+  _regionType: string,
+  fn: (() => void) | null,
+): void {
+  fn?.()
+}
+
+export function StartRegion(
+  _ctx: context.Context | null,
+  _regionType: string,
+): Region {
+  return new Region()
+}
+
+export function IsEnabled(): boolean {
+  return false
+}
+
+export function Start(w: io.Writer | $.VarRef<io.Writer> | null): $.GoError {
+  const writer = $.pointerValueOrNil(w)
+  if (writer == null) {
+    return errors.New('runtime/trace: nil trace writer')
+  }
+  if (traceState.activeWriter != null) {
+    return errors.New('runtime/trace: trace already active')
+  }
+  traceState.activeWriter = writer
+  return writeTrace('goscript trace start\n')
+}
+
+export function Stop(): void {
+  writeTrace('goscript trace stop\n')
+  traceState.activeWriter = null
+}
+
+function writeTrace(text: string): $.GoError {
+  const writer = traceState.activeWriter
+  if (writer == null) {
+    return null
+  }
+  const [, err] = writer.Write($.stringToBytes(text))
+  return err
+}

package/gs/runtime/trace/meta.json

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

package/gs/slices/meta.json

@@ -1,5 +1,6 @@
 {
   "dependencies": [
-    "cmp"
+    "cmp",
+    "iter"
   ]
 }