goscript 0.1.4 → 0.2.1

package/gs/reflect/value.ts

@@ -13,6 +13,8 @@ import {
   PointerTo,
   Ptr,
   Slice,
+  SliceOf,
+  Struct,
   String,
   Type,
   Uint,
@@ -25,6 +27,8 @@ import {
   Chan,
   BasicType,
   Invalid,
+  structFieldStorageKey,
+  typeInfoFromReflectType,
 } from './type.js'
 import {
   Pointer,
@@ -44,12 +48,13 @@ export function Zero(typ: Type | null): Value {
   if (typ === null) {
     return new Value() // Return invalid value for null type
   }
-  let zeroValue: ReflectValue
+  return new Value(zeroReflectValue(typ), typ)
+}
 
+function zeroReflectValue(typ: Type): ReflectValue {
   switch (typ.Kind()) {
     case Bool:
-      zeroValue = false
-      break
+      return false
     case Int:
     case Int8:
     case Int16:
@@ -63,21 +68,61 @@ export function Zero(typ: Type | null): Value {
     case Uintptr:
     case Float32:
     case Float64:
-      zeroValue = 0
-      break
+      return 0
     case String:
-      zeroValue = ''
-      break
+      return ''
     case Slice:
     case Array:
-      zeroValue = []
-      break
+      return []
+    case Struct: {
+      const typeInfo = $.getTypeByName(typ.String())
+      if (typeInfo && $.isStructTypeInfo(typeInfo) && typeInfo.ctor) {
+        return $.markAsStructValue(new typeInfo.ctor()) as ReflectValue
+      }
+      return newStructValue(typ)
+    }
     default:
-      zeroValue = null
-      break
+      return null
   }
+}
 
-  return new Value(zeroValue, typ)
+function newStructValue(typ: Type): ReflectValue {
+  const StructValue = class {
+    public _fields: Record<string, $.VarRef<unknown>> = {}
+
+    public clone(): unknown {
+      const cloned = newStructValue(typ) as {
+        _fields: Record<string, $.VarRef<unknown>>
+      }
+      for (const key of Object.keys(this._fields)) {
+        cloned._fields[key].value = this._fields[key].value
+      }
+      return cloned
+    }
+  }
+  Object.defineProperty(StructValue, '__reflectType', { value: typ })
+  Object.defineProperty(StructValue, '__typeInfo', {
+    value: typeInfoFromReflectType(typ),
+  })
+
+  const value = new StructValue() as unknown as {
+    _fields: Record<string, $.VarRef<ReflectValue>>
+  } & Record<string, unknown>
+  for (let i = 0; i < typ.NumField(); i++) {
+    const field = typ.Field(i)
+    const key = structFieldStorageKey(typ, i)
+    const ref = $.varRef<ReflectValue>(zeroReflectValue(field.Type))
+    value._fields[key] = ref
+    Object.defineProperty(value, key, {
+      enumerable: true,
+      configurable: true,
+      get: () => ref.value,
+      set: (next: unknown) => {
+        ref.value = next as ReflectValue
+      },
+    })
+  }
+  return value
 }
 
 // Copy copies the contents of src to dst until either dst has been filled
@@ -120,20 +165,12 @@ function getArrayFromValue(value: Value): unknown[] | null {
 
 // Indirect returns the value that v points to.
 export function Indirect(v: Value): Value {
-  // Check if this is a pointer type
-  const type = v.Type()
-  if (type.Kind() === Ptr) {
-    // Ptr kind
-    const elemType = type.Elem()
-    if (elemType) {
-      // Return a new Value with the same underlying value but the element type
-      return new Value(
-        (v as unknown as { value: ReflectValue }).value,
-        elemType,
-      )
+  if (v.Kind() === Ptr) {
+    if (v.IsNil()) {
+      return new Value()
     }
+    return v.Elem()
   }
-  // For non-pointer types, just return the value as-is
   return v
 }
 
@@ -143,9 +180,7 @@ export function New(typ: Type | null): Value {
     return new Value() // Return invalid value for null type
   }
   const ptrType = PointerTo(typ)
-  // For the pointer value, we'll use the zero value but with pointer type
-  // In a real implementation, this would be a pointer to the zero value
-  return new Value(null, ptrType) // null represents the pointer value
+  return new Value($.varRef(zeroReflectValue(typ)), ptrType)
 }
 
 // NewAt returns a Value representing a pointer to the value at p.
@@ -154,25 +189,50 @@ export function NewAt(typ: Type | null, p: Pointer | unknown): Value {
     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)
+  const pointer = ownedPointerHandleFromPointerArg(p)
+  if (pointer !== undefined) {
+    return new Value(
+      $.ownedPointerRef(pointer) as $.VarRef<ReflectValue>,
+      ptrType,
+    )
+  }
+  throw new Error('reflect.NewAt requires a GoScript-owned pointer')
+}
+
+export function SliceAt(
+  typ: Type | null,
+  p: Pointer | unknown,
+  n: number,
+): Value {
+  if (typ === null) {
+    return new Value()
+  }
+  if (n < 0) {
+    throw new Error('reflect.SliceAt: negative length')
+  }
+  if (p === null && n === 0) {
+    return new Value(null, SliceOf(typ))
+  }
+  const pointer = ownedPointerHandleFromPointerArg(p)
+  if (pointer === undefined) {
+    throw new Error('reflect.SliceAt requires a GoScript-owned pointer')
+  }
+  const slice = $.sliceFromOwnedPointer(pointer, n)
+  return new Value(slice as ReflectValue, SliceOf(typ))
+}
+
+function ownedPointerHandleFromPointerArg(
+  p: unknown,
+): $.OwnedPointerHandle<ReflectValue> | undefined {
+  if ($.isOwnedPointerHandle(p)) {
+    return p as $.OwnedPointerHandle<ReflectValue>
+  }
+  if ($.isVarRef(p)) {
+    return $.ownedPointerFromRef(p as $.VarRef<ReflectValue>) as
+      | $.OwnedPointerHandle<ReflectValue>
+      | undefined
   }
-  return new Value($.unsupportedPointerRef<ReflectValue>(p), ptrType)
+  return undefined
 }
 
 // MakeSlice returns a Value representing a new slice with the specified type, length, and capacity.

package/gs/reflect/visiblefields.ts

@@ -1,177 +1,14 @@
 import * as $ from '@goscript/builtin/index.js'
-import { Type, Ptr, Struct } from './type.js'
+import { Struct, Type, visibleStructFields } from './type.js'
 import { StructField } from './types.js'
 
-// VisibleFields returns all the visible fields in t, which must be a
-// struct type. A field is defined as visible if it's accessible
-// directly with a FieldByName call. The returned fields include fields
-// inside anonymous struct members and unexported fields. They follow
-// the same order found in the struct, with anonymous fields followed
-// immediately by their promoted fields.
-//
-// For each element e of the returned slice, the corresponding field
-// can be retrieved from a value v of type t by calling v.FieldByIndex(e.Index).
+// VisibleFields returns all fields visible through ordinary struct field lookup.
 export function VisibleFields(t: Type): $.Slice<StructField> {
   if (t == null) {
     $.panic('reflect: VisibleFields(nil)')
   }
-  if (t!.Kind() != 25) {
-    $.panic('reflect.VisibleFields of non-struct type ' + t!.String())
+  if (t.Kind() !== Struct) {
+    $.panic('reflect.VisibleFields of non-struct type ' + t.String())
   }
-  let w = new visibleFieldsWalker({
-    byName: $.makeMap<string, number>(),
-    fields: $.makeSlice<StructField>(0, t!.NumField!()),
-    index: $.makeSlice<number>(0, 2, 'number'),
-    visiting: $.makeMap<Type, boolean>(),
-  })
-  w.walk(t)
-  // Remove all the fields that have been hidden.
-  // Use an in-place removal that avoids copying in
-  // the common case that there are no hidden fields.
-  let j = 0
-
-  // A field has been removed. We need to shuffle
-  // all the subsequent elements up.
-  for (let i = 0; i < $.len(w.fields); i++) {
-    {
-      let f = w.fields![i]
-      if (f!.Name == '') {
-        continue
-      }
-
-      // A field has been removed. We need to shuffle
-      // all the subsequent elements up.
-      if (i != j) {
-        // A field has been removed. We need to shuffle
-        // all the subsequent elements up.
-        w.fields![j] = f!.clone()
-      }
-      j++
-    }
-  }
-  return $.goSlice(w.fields, undefined, j)
-}
-
-class visibleFieldsWalker {
-  public get byName(): Map<string, number> {
-    return this._fields.byName.value
-  }
-  public set byName(value: Map<string, number>) {
-    this._fields.byName.value = value
-  }
-
-  public get visiting(): Map<Type, boolean> {
-    return this._fields.visiting.value
-  }
-  public set visiting(value: Map<Type, boolean>) {
-    this._fields.visiting.value = value
-  }
-
-  public get fields(): $.Slice<StructField> {
-    return this._fields.fields.value
-  }
-  public set fields(value: $.Slice<StructField>) {
-    this._fields.fields.value = value
-  }
-
-  public get index(): $.Slice<number> {
-    return this._fields.index.value
-  }
-  public set index(value: $.Slice<number>) {
-    this._fields.index.value = value
-  }
-
-  public _fields: {
-    byName: $.VarRef<Map<string, number>>
-    visiting: $.VarRef<Map<Type, boolean>>
-    fields: $.VarRef<$.Slice<StructField>>
-    index: $.VarRef<$.Slice<number>>
-  }
-
-  constructor(
-    init?: Partial<{
-      byName?: Map<string, number>
-      fields?: $.Slice<StructField>
-      index?: $.Slice<number>
-      visiting?: Map<Type, boolean>
-    }>,
-  ) {
-    this._fields = {
-      byName: $.varRef(init?.byName ?? $.makeMap<string, number>()),
-      visiting: $.varRef(init?.visiting ?? $.makeMap<Type, boolean>()),
-      fields: $.varRef(init?.fields ?? $.makeSlice<StructField>(0, 0)),
-      index: $.varRef(init?.index ?? $.makeSlice<number>(0, 2, 'number')),
-    }
-  }
-
-  public clone(): visibleFieldsWalker {
-    const cloned = new visibleFieldsWalker()
-    cloned._fields = {
-      byName: $.varRef(this._fields.byName.value),
-      visiting: $.varRef(this._fields.visiting.value),
-      fields: $.varRef(this._fields.fields.value),
-      index: $.varRef(this._fields.index.value),
-    }
-    return cloned
-  }
-
-  // walk walks all the fields in the struct type t, visiting
-  // fields in index preorder and appending them to w.fields
-  // (this maintains the required ordering).
-  // Fields that have been overridden have their
-  // Name field cleared.
-  public walk(t: Type): void {
-    const w = this
-    if ($.mapGet(w.visiting, t, false)[0]) {
-      return
-    }
-    $.mapSet(w.visiting, t, true)
-    for (let i = 0; i < t!.NumField!(); i++) {
-      if (!t!.Field) continue
-      const field = t!.Field(i)
-      if (field) {
-        const f = field.clone()
-        f.Index = $.append(null, ...(w.index ?? [])) as number[]
-        if (f.Anonymous) {
-          if (f.Type && f.Type.Kind() === Ptr) {
-            const elemType = f.Type.Elem!()
-            if (elemType) {
-              f.Type = elemType
-            }
-          }
-          if (f.Type && f.Type.Kind() === Struct) {
-            w.walk(f.Type)
-          }
-        } else {
-          w.fields = $.append(w.fields, f)
-        }
-      }
-    }
-    $.deleteMapEntry(w.visiting, t)
-  }
-
-  // Register this type with the runtime type system
-  static __typeInfo = $.registerStructType(
-    'visibleFieldsWalker',
-    new visibleFieldsWalker(),
-    [{ name: 'walk', args: [{ name: 't', type: 'Type' }], returns: [] }],
-    visibleFieldsWalker,
-    {
-      byName: {
-        kind: $.TypeKind.Map,
-        keyType: { kind: $.TypeKind.Basic, name: 'string' },
-        elemType: { kind: $.TypeKind.Basic, name: 'number' },
-      },
-      visiting: {
-        kind: $.TypeKind.Map,
-        keyType: 'Type',
-        elemType: { kind: $.TypeKind.Basic, name: 'boolean' },
-      },
-      fields: { kind: $.TypeKind.Slice, elemType: 'StructField' },
-      index: {
-        kind: $.TypeKind.Slice,
-        elemType: { kind: $.TypeKind.Basic, name: 'number' },
-      },
-    },
-  )
+  return $.arrayToSlice(visibleStructFields(t).map((field) => field.clone()))
 }

package/gs/runtime/parity.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": 1,
+  "strict": false,
+  "symbols": {
+    "Compiler": {
+      "status": "real"
+    },
+    "GOARCH": {
+      "status": "real"
+    },
+    "GOOS": {
+      "status": "real"
+    },
+    "ReadTrace": {
+      "status": "real"
+    },
+    "StartTrace": {
+      "status": "real"
+    },
+    "StopTrace": {
+      "status": "real"
+    }
+  }
+}

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

@@ -1,9 +1,9 @@
 import { describe, expect, it } from 'vitest'
 
-import { Lookup, StartCPUProfile, StopCPUProfile } from './index.js'
+import { Lookup, NewProfile, StartCPUProfile, StopCPUProfile, WriteHeapProfile } from './index.js'
 
 describe('runtime/pprof override', () => {
-  it('writes deterministic CPU profile bytes', () => {
+  it('reports CPU profiles as unsupported', () => {
     const chunks: Uint8Array[] = []
     const writer = {
       Write(p: Uint8Array): [number, null] {
@@ -12,13 +12,15 @@ describe('runtime/pprof override', () => {
       },
     }
 
-    expect(StartCPUProfile(writer)).toBeNull()
+    expect(StartCPUProfile(writer)?.Error()).toBe(
+      'runtime/pprof: profiles are unsupported in GoScript',
+    )
     StopCPUProfile()
 
-    expect(chunks.reduce((total, chunk) => total + chunk.length, 0)).toBeGreaterThan(0)
+    expect(chunks).toHaveLength(0)
   })
 
-  it('writes deterministic memory profile bytes', () => {
+  it('reports memory profiles as unsupported', () => {
     const chunks: Uint8Array[] = []
     const writer = {
       Write(p: Uint8Array): [number, null] {
@@ -30,7 +32,27 @@ describe('runtime/pprof override', () => {
     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)
+    expect(profile!.WriteTo(writer, 0)?.Error()).toBe(
+      'runtime/pprof: profiles are unsupported in GoScript',
+    )
+    expect(WriteHeapProfile(writer)?.Error()).toBe(
+      'runtime/pprof: profiles are unsupported in GoScript',
+    )
+    expect(chunks).toHaveLength(0)
+  })
+
+  it('tracks custom profile values', () => {
+    const profile = NewProfile('goscript.test')
+    const value = { key: 'value' }
+
+    expect(Lookup('goscript.test')).toBe(profile)
+    expect(profile.Count()).toBe(0)
+    profile.Add(value, 0)
+    expect(profile.Count()).toBe(1)
+    profile.Remove(value)
+    expect(profile.Count()).toBe(0)
+    expect(() => NewProfile('goscript.test')).toThrow(
+      'pprof: NewProfile name already in use: goscript.test',
+    )
   })
 })

package/gs/runtime/pprof/index.ts

@@ -4,13 +4,18 @@ import * as io from '@goscript/io/index.js'
 
 type WriterArg = io.Writer | $.VarRef<io.Writer> | null | undefined
 
-let activeCPUWriter: io.Writer | null = null
+const unsupportedProfileError = errors.New(
+  'runtime/pprof: profiles are unsupported in GoScript',
+)
 
 export class Profile {
   public name: string
+  private values = new Map<unknown, true>()
+  private builtIn: boolean
 
-  constructor(name = '') {
+  constructor(name = '', builtIn = false) {
     this.name = name
+    this.builtIn = builtIn
   }
 
   public Name(): string {
@@ -18,11 +23,28 @@ export class Profile {
   }
 
   public Count(): number {
-    return this.name === '' ? 0 : 1
+    return this.builtIn && this.name !== '' ? 1 : this.values.size
   }
 
-  public WriteTo(w: WriterArg, debug: number): $.GoError {
-    return writeProfile(w, `goscript pprof ${this.name} debug=${debug}\n`)
+  public Add(value: unknown, _skip: number): void {
+    if (this.name === '') {
+      throw new Error('pprof: use of uninitialized Profile')
+    }
+    if (this.builtIn) {
+      throw new Error(`pprof: Add called on built-in Profile ${this.name}`)
+    }
+    if (this.values.has(value)) {
+      throw new Error('pprof: Profile.Add of duplicate value')
+    }
+    this.values.set(value, true)
+  }
+
+  public Remove(value: unknown): void {
+    this.values.delete(value)
+  }
+
+  public WriteTo(_w: WriterArg, _debug: number): $.GoError {
+    return unsupportedProfileError
   }
 }
 
@@ -34,40 +56,51 @@ export function Lookup(name: string): Profile | null {
     case 'threadcreate':
     case 'block':
     case 'mutex':
-      return new Profile(name)
+      return new Profile(name, true)
     default:
-      return null
+      return customProfiles.get(name) ?? 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'),
+    new Profile('allocs', true),
+    new Profile('block', true),
+    new Profile('goroutine', true),
+    new Profile('heap', true),
+    new Profile('mutex', true),
+    new Profile('threadcreate', true),
+    ...Array.from(customProfiles.values()),
   ])
 }
 
+export function NewProfile(name: string): Profile {
+  if (name === '') {
+    throw new Error('pprof: NewProfile with empty name')
+  }
+  if (Lookup(name) != null) {
+    throw new Error(`pprof: NewProfile name already in use: ${name}`)
+  }
+  const profile = new Profile(name)
+  customProfiles.set(name, profile)
+  return profile
+}
+
 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')
+  return unsupportedProfileError
 }
 
-export function StopCPUProfile(): void {
-  if (activeCPUWriter != null) {
-    writeProfile(activeCPUWriter, 'goscript cpu profile stop\n')
-    activeCPUWriter = null
+export function StopCPUProfile(): void {}
+
+export function WriteHeapProfile(w: WriterArg): $.GoError {
+  if (writerFromArg(w) == null) {
+    return errors.New('runtime/pprof: nil profile writer')
   }
+  return unsupportedProfileError
 }
 
 export function SetGoroutineLabels(_ctx: unknown): void {}
@@ -94,11 +127,4 @@ 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
-}
+const customProfiles = new Map<string, Profile>()

package/gs/runtime/pprof/parity.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 1,
+  "strict": false,
+  "symbols": {
+    "Lookup": {
+      "status": "real"
+    },
+    "NewProfile": {
+      "status": "real"
+    },
+    "Profile": {
+      "status": "real"
+    },
+    "Profiles": {
+      "status": "real"
+    },
+    "StartCPUProfile": {
+      "status": "real"
+    },
+    "StopCPUProfile": {
+      "status": "real"
+    },
+    "WriteHeapProfile": {
+      "status": "real"
+    }
+  }
+}

package/gs/runtime/runtime.test.ts

@@ -12,7 +12,9 @@ describe('runtime override', () => {
   it('exposes stack and trace compatibility helpers', () => {
     expect(Compiler).toBe('gc')
     expect(FuncForPC(0)).toBeNull()
-    expect(StartTrace()).toBeNull()
+    expect(StartTrace()?.Error()).toBe(
+      'runtime: execution tracing is unsupported in GoScript',
+    )
     expect(ReadTrace()).toBeNull()
     expect(() => StopTrace()).not.toThrow()
   })

package/gs/runtime/runtime.ts

@@ -36,8 +36,9 @@ export function NumCPU(): number {
 export function GC(): void {
   // In JavaScript, we can't force garbage collection
   // Some engines have gc() function in development, but it's not standard
-  if (typeof globalThis.gc === 'function') {
-    ;(globalThis as any).gc()
+  const gc = (globalThis as { gc?: () => void }).gc
+  if (typeof gc === 'function') {
+    gc()
   }
   // Otherwise, this is a no-op
 }
@@ -104,7 +105,7 @@ export function FuncForPC(_pc: number): Func | null {
 
 // StartTrace enables execution tracing.
 export function StartTrace(): $.GoError {
-  return null
+  return $.newError('runtime: execution tracing is unsupported in GoScript')
 }
 
 // StopTrace stops execution tracing.