goscript 0.1.4 → 0.2.1

package/gs/builtin/type.ts

@@ -45,8 +45,14 @@ export interface MethodSignature {
  */
 export interface StructFieldInfo {
   type: TypeInfo | string // The field's type
-  name?: string // The Go field name when it differs from the TypeScript key.
+  name: string // The Go field name.
+  key?: string // The runtime storage key on generated or dynamic values.
   tag?: string // The struct field tag (e.g., `json:"name,omitempty"`)
+  pkgPath?: string // Non-empty for unexported fields.
+  anonymous?: boolean
+  index?: number[]
+  offset?: number
+  exported?: boolean
 }
 
 /**
@@ -56,7 +62,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Struct
   methods: MethodSignature[] // Array of method signatures
   ctor?: new (...args: any[]) => any
-  fields: Record<string, TypeInfo | string | StructFieldInfo> // Field names and types for struct fields
+  fields: StructFieldInfo[] // Ordered field descriptors.
 }
 
 /**
@@ -185,12 +191,13 @@ export function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeInfo {
  * vs a direct TypeInfo or string
  */
 export function isStructFieldInfo(
-  fieldValue: TypeInfo | string | StructFieldInfo,
+  fieldValue: unknown,
 ): fieldValue is StructFieldInfo {
   return (
     typeof fieldValue === 'object' &&
     fieldValue !== null &&
     'type' in fieldValue &&
+    'name' in fieldValue &&
     !('kind' in fieldValue)
   )
 }
@@ -234,7 +241,7 @@ export const registerStructType = (
   zeroValue: any,
   methods: MethodSignature[],
   ctor: new (...args: any[]) => any,
-  fields: Record<string, TypeInfo | string | StructFieldInfo> = {},
+  fields: StructFieldInfo[] = [],
 ): StructTypeInfo => {
   const typeInfo: StructTypeInfo = {
     name,
@@ -327,26 +334,62 @@ function goTypeMatchesTypeInfo(goType: string, info: TypeInfo): boolean {
   )
 }
 
+interface TypeInfoComparisonState {
+  seenPairs: Set<string>
+  objectIDs: WeakMap<object, number>
+  nextObjectID: number
+}
+
+function newTypeInfoComparisonState(): TypeInfoComparisonState {
+  return {
+    seenPairs: new Set(),
+    objectIDs: new WeakMap(),
+    nextObjectID: 0,
+  }
+}
+
+function typeInfoComparisonID(
+  raw: string | TypeInfo,
+  normalized: TypeInfo,
+  state: TypeInfoComparisonState,
+): string {
+  const runtimeName = typeInfoRuntimeName(normalized)
+  if (runtimeName !== undefined) {
+    return `${normalized.kind}:${runtimeName}`
+  }
+  if (typeof raw === 'string') {
+    return `string:${raw}`
+  }
+  const existing = state.objectIDs.get(raw)
+  if (existing !== undefined) {
+    return `object:${existing}`
+  }
+  const id = state.nextObjectID
+  state.nextObjectID += 1
+  state.objectIDs.set(raw, id)
+  return `object:${id}`
+}
+
 function compareOptionalTypeInfo(
-  type1?: string | TypeInfo,
-  type2?: string | TypeInfo,
+  type1: string | TypeInfo | undefined,
+  type2: string | TypeInfo | undefined,
+  state: TypeInfoComparisonState,
 ): boolean {
   if (type1 === undefined && type2 === undefined) return true
   if (type1 === undefined || type2 === undefined) return false
-  // Assuming areTypeInfosIdentical will handle normalization if needed,
-  // but type1 and type2 here are expected to be direct fields from TypeInfo objects.
-  return areTypeInfosIdentical(type1, type2)
+  return areTypeInfosIdenticalWithSeen(type1, type2, state)
 }
 
 function areFuncParamOrResultArraysIdentical(
   arr1?: (string | TypeInfo)[],
   arr2?: (string | TypeInfo)[],
+  state = newTypeInfoComparisonState(),
 ): boolean {
   if (arr1 === undefined && arr2 === undefined) return true
   if (arr1 === undefined || arr2 === undefined) return false
   if (arr1.length !== arr2.length) return false
-  for (let i = 0; i < arr1.length; i++) {
-    if (!areTypeInfosIdentical(arr1[i], arr2[i])) {
+  for (const [index, typeInfo] of arr1.entries()) {
+    if (!areTypeInfosIdenticalWithSeen(typeInfo, arr2[index], state)) {
       return false
     }
   }
@@ -356,58 +399,75 @@ function areFuncParamOrResultArraysIdentical(
 function areFuncSignaturesIdentical(
   func1: FunctionTypeInfo,
   func2: FunctionTypeInfo,
+  state = newTypeInfoComparisonState(),
 ): boolean {
   if ((func1.isVariadic || false) !== (func2.isVariadic || false)) {
     return false
   }
   return (
-    areFuncParamOrResultArraysIdentical(func1.params, func2.params) &&
-    areFuncParamOrResultArraysIdentical(func1.results, func2.results)
+    areFuncParamOrResultArraysIdentical(func1.params, func2.params, state) &&
+    areFuncParamOrResultArraysIdentical(func1.results, func2.results, state)
   )
 }
 
 export function areTypeInfosIdentical(
   type1InfoOrName: string | TypeInfo,
   type2InfoOrName: string | TypeInfo,
+): boolean {
+  return areTypeInfosIdenticalWithSeen(
+    type1InfoOrName,
+    type2InfoOrName,
+    newTypeInfoComparisonState(),
+  )
+}
+
+function areTypeInfosIdenticalWithSeen(
+  type1InfoOrName: string | TypeInfo,
+  type2InfoOrName: string | TypeInfo,
+  state: TypeInfoComparisonState,
 ): boolean {
   const t1Norm = normalizeTypeInfo(type1InfoOrName)
   const t2Norm = normalizeTypeInfo(type2InfoOrName)
 
-  if (t1Norm === t2Norm) return true // Object identity
+  if (t1Norm === t2Norm) return true
   if (t1Norm.kind !== t2Norm.kind) return false
 
-  // If types have names, the names must match for identity.
-  // If one has a name and the other doesn't, they are not identical.
+  if ((t1Norm.typeName ?? '') !== (t2Norm.typeName ?? '')) return false
   if (t1Norm.name !== t2Norm.name) return false
 
-  // If both are named and names match, for Basic, Struct, Interface, this is sufficient for identity.
   if (
-    t1Norm.name !== undefined /* && t2Norm.name is also defined and equal */
-  ) {
-    if (
-      t1Norm.kind === TypeKind.Basic ||
+    t1Norm.name !== undefined &&
+    (t1Norm.kind === TypeKind.Basic ||
       t1Norm.kind === TypeKind.Struct ||
-      t1Norm.kind === TypeKind.Interface
-    ) {
-      return true
-    }
+      t1Norm.kind === TypeKind.Interface)
+  ) {
+    return true
+  }
+
+  const pairKey = `${typeInfoComparisonID(
+    type1InfoOrName,
+    t1Norm,
+    state,
+  )}|${typeInfoComparisonID(type2InfoOrName, t2Norm, state)}`
+  if (state.seenPairs.has(pairKey)) {
+    return true
   }
-  // For other types (Pointer, Slice, etc.), or if both are anonymous (name is undefined),
-  // structural comparison is needed.
+  state.seenPairs.add(pairKey)
 
   switch (t1Norm.kind) {
     case TypeKind.Basic:
-      // Names matched if they were defined, or both undefined (which means true by t1Norm.name !== t2Norm.name being false)
       return true
     case TypeKind.Pointer:
       return compareOptionalTypeInfo(
         (t1Norm as PointerTypeInfo).elemType,
         (t2Norm as PointerTypeInfo).elemType,
+        state,
       )
     case TypeKind.Slice:
       return compareOptionalTypeInfo(
         (t1Norm as SliceTypeInfo).elemType,
         (t2Norm as SliceTypeInfo).elemType,
+        state,
       )
     case TypeKind.Array:
       return (
@@ -415,6 +475,7 @@ export function areTypeInfosIdentical(
         compareOptionalTypeInfo(
           (t1Norm as ArrayTypeInfo).elemType,
           (t2Norm as ArrayTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Map:
@@ -422,39 +483,119 @@ export function areTypeInfosIdentical(
         compareOptionalTypeInfo(
           (t1Norm as MapTypeInfo).keyType,
           (t2Norm as MapTypeInfo).keyType,
+          state,
         ) &&
         compareOptionalTypeInfo(
           (t1Norm as MapTypeInfo).elemType,
           (t2Norm as MapTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Channel:
       return (
-        // Ensure direction property exists before comparing, or handle undefined if it can be
         ((t1Norm as ChannelTypeInfo).direction || 'both') ===
           ((t2Norm as ChannelTypeInfo).direction || 'both') &&
         compareOptionalTypeInfo(
           (t1Norm as ChannelTypeInfo).elemType,
           (t2Norm as ChannelTypeInfo).elemType,
+          state,
         )
       )
     case TypeKind.Function:
       return areFuncSignaturesIdentical(
         t1Norm as FunctionTypeInfo,
         t2Norm as FunctionTypeInfo,
+        state,
       )
     case TypeKind.Struct:
+      if (t2Norm.kind !== TypeKind.Struct) {
+        return false
+      }
+      return areStructTypeInfosIdentical(t1Norm, t2Norm, state)
     case TypeKind.Interface:
-      // If we reach here, names were undefined (both anonymous) or names matched but was not Basic/Struct/Interface.
-      // For anonymous Struct/Interface, strict identity means full structural comparison.
-      // For now, we consider anonymous types not identical unless they are the same object (caught above).
-      // If they were named and matched, 'return true' was hit earlier for these kinds.
-      return false
+      if (t2Norm.kind !== TypeKind.Interface) {
+        return false
+      }
+      return areInterfaceTypeInfosIdentical(t1Norm, t2Norm, state)
     default:
       return false
   }
 }
 
+function areStructTypeInfosIdentical(
+  struct1: StructTypeInfo,
+  struct2: StructTypeInfo,
+  state: TypeInfoComparisonState,
+): boolean {
+  if (struct1.fields.length !== struct2.fields.length) {
+    return false
+  }
+  for (const [index, field1] of struct1.fields.entries()) {
+    const field2 = struct2.fields[index]
+    if (
+      field2 === undefined ||
+      field1.name !== field2.name ||
+      (field1.pkgPath ?? '') !== (field2.pkgPath ?? '') ||
+      (field1.tag ?? '') !== (field2.tag ?? '') ||
+      (field1.anonymous ?? false) !== (field2.anonymous ?? false) ||
+      !areTypeInfosIdenticalWithSeen(field1.type, field2.type, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+function areInterfaceTypeInfosIdentical(
+  interface1: InterfaceTypeInfo,
+  interface2: InterfaceTypeInfo,
+  state: TypeInfoComparisonState,
+): boolean {
+  const methods1 = sortedMethodSignatures(interface1.methods)
+  const methods2 = sortedMethodSignatures(interface2.methods)
+  if (methods1.length !== methods2.length) {
+    return false
+  }
+  for (const [index, method1] of methods1.entries()) {
+    const method2 = methods2[index]
+    if (
+      method2 === undefined ||
+      method1.name !== method2.name ||
+      !areMethodArgArraysIdentical(method1.args, method2.args, state) ||
+      !areMethodArgArraysIdentical(method1.returns, method2.returns, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
+function sortedMethodSignatures(
+  methods: MethodSignature[] = [],
+): MethodSignature[] {
+  return [...methods].sort((left, right) => left.name.localeCompare(right.name))
+}
+
+function areMethodArgArraysIdentical(
+  args1: MethodArg[],
+  args2: MethodArg[],
+  state: TypeInfoComparisonState,
+): boolean {
+  if (args1.length !== args2.length) {
+    return false
+  }
+  for (const [index, arg1] of args1.entries()) {
+    const arg2 = args2[index]
+    if (
+      arg2 === undefined ||
+      !areTypeInfosIdenticalWithSeen(arg1.type, arg2.type, state)
+    ) {
+      return false
+    }
+  }
+  return true
+}
+
 /**
  * Validates that a map key matches the expected type info.
  *
@@ -539,7 +680,8 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
 
   // For anonymous struct types (no constructor), use structural matching
   if (typeof value === 'object' && value !== null && info.fields) {
-    const fieldNames = Object.keys(info.fields || {})
+    const fields = info.fields || []
+    const fieldNames = fields.map((field) => structFieldRuntimeKey(field))
     const valueFields = Object.keys(value)
 
     const fieldsExist = fieldNames.every((field) => field in value)
@@ -549,10 +691,9 @@ 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(fieldTypeInfo))
+      return fields.every((field) => {
+        const key = structFieldRuntimeKey(field)
+        return matchesType(value[key], normalizeTypeInfo(field.type))
       })
     }
 
@@ -562,6 +703,10 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
   return false
 }
 
+export function structFieldRuntimeKey(field: StructFieldInfo): string {
+  return field.key || field.name
+}
+
 /**
  * Checks if a value matches an interface type info by verifying it implements
  * all required methods with compatible signatures.
@@ -879,17 +1024,30 @@ function matchesPointerType(value: any, info: TypeInfo): boolean {
  * @returns True if the value matches the function type, false otherwise.
  */
 function matchesFunctionType(value: any, info: FunctionTypeInfo): boolean {
-  // First check if the value is a function
   if (typeof value !== 'function') {
     return false
   }
-
-  // This is important for named function types
-  if (info.name && value.__goTypeName) {
-    return info.name === value.__goTypeName
+  const valueInfo = functionValueTypeInfo(value)
+  if (!valueInfo) {
+    return false
   }
+  return areTypeInfosIdentical(valueInfo, info)
+}
 
-  return true
+function functionValueTypeInfo(value: any): FunctionTypeInfo | null {
+  const typeInfo = value.__typeInfo
+  if (!typeInfo || typeInfo.kind !== TypeKind.Function) {
+    return null
+  }
+  const goTypeName =
+    typeof value.__goTypeName === 'string' ? value.__goTypeName : undefined
+  if (goTypeName && typeInfo.name && goTypeName !== typeInfo.name) {
+    return null
+  }
+  if (goTypeName && !typeInfo.name) {
+    return { ...typeInfo, name: goTypeName }
+  }
+  return typeInfo
 }
 
 /**
@@ -1062,8 +1220,8 @@ function compareTypeStringWithTypeInfo(
       }
 
       // Compare fields
-      const typeInfoFields = elemTypeInfo.fields || {}
-      const typeInfoFieldNames = Object.keys(typeInfoFields)
+      const typeInfoFields = elemTypeInfo.fields || []
+      const typeInfoFieldNames = typeInfoFields.map((field) => field.name)
       const parsedFieldNames = Object.keys(parsedFields)
 
       if (typeInfoFieldNames.length !== parsedFieldNames.length) {
@@ -1071,16 +1229,13 @@ function compareTypeStringWithTypeInfo(
       }
 
       // Check if all field names match and types are compatible
-      for (const fieldName of typeInfoFieldNames) {
+      for (const field of typeInfoFields) {
+        const fieldName = field.name
         if (!(fieldName in parsedFields)) {
           return false
         }
 
-        const fieldValue = typeInfoFields[fieldName]
-        // Handle StructFieldInfo (which has 'type' and optional 'tag' properties)
-        const fieldTypeInfo: TypeInfo | string =
-          isStructFieldInfo(fieldValue) ? fieldValue.type : fieldValue
-        const typeInfoFieldType = normalizeTypeInfo(fieldTypeInfo)
+        const typeInfoFieldType = normalizeTypeInfo(field.type)
         const parsedFieldType = parsedFields[fieldName]
 
         // Compare basic types
@@ -1107,9 +1262,6 @@ function compareTypeStringWithTypeInfo(
     if (typeof elemType === 'string') {
       return elemStr === elemType
     }
-    if (elemType.name) {
-      return elemStr === elemType.name
-    }
     return compareTypeStringWithTypeInfo(elemStr, elemType)
   }
 
@@ -1463,24 +1615,39 @@ export function namedValueInterfaceValue<T>(
   return boxed as T
 }
 
-export function namedFunction<T>(fn: T, typeName: string): T {
+export function namedFunction<T>(
+  fn: T,
+  typeName: string,
+  typeInfo?: FunctionTypeInfo,
+): T {
   if (typeof fn !== 'function') {
     return fn
   }
-  return Object.assign(fn, { __goTypeName: typeName })
+  return Object.assign(
+    fn,
+    typeInfo ?
+      { __goTypeName: typeName, __typeInfo: typeInfo }
+    : { __goTypeName: typeName },
+  )
 }
 
 export function functionValue<T extends (...args: any[]) => any>(
   fn: T,
   typeInfo: FunctionTypeInfo,
 ): T {
-  return Object.assign(fn, { __typeInfo: typeInfo })
+  return Object.assign(
+    fn,
+    typeInfo.name ?
+      { __typeInfo: typeInfo, __goTypeName: typeInfo.name }
+    : { __typeInfo: typeInfo },
+  )
 }
 
 export interface GenericTypeDescriptor<T = any> {
   type?: TypeInfo | string
   zero?: () => T
   methods?: Record<string, (receiver: T, ...args: any[]) => any>
+  methodSignatures?: MethodSignature[]
 }
 
 export type GenericTypeArgs = Record<string, GenericTypeDescriptor>

package/gs/builtin/varRef.ts

@@ -1,3 +1,10 @@
+export interface OwnedPointerHandle<T = unknown> {
+  readonly __goOwnedPointer: true
+  __goAddress: () => number
+  __goRef: () => VarRef<T>
+  __goSlice?: (length: number) => unknown
+}
+
 /**
  * VarRef represents a Go variable which can be referred to by other variables.
  *
@@ -12,6 +19,51 @@ export type VarRef<T> = {
   __goAddress?: () => number
   __goCollection?: unknown
   __goIndex?: number
+  __goPointer?: OwnedPointerHandle<T>
+}
+
+const pointerAddressStride = 0x100000000
+const pointerAddresses = new WeakMap<object, number>()
+const fieldPointerAddresses = new WeakMap<
+  object,
+  globalThis.Map<PropertyKey, number>
+>()
+let nextPointerAddress = 1
+
+function pointerAddress(value: object): number {
+  let address = pointerAddresses.get(value)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    pointerAddresses.set(value, address)
+  }
+  return address
+}
+
+function fieldPointerAddress(target: object, key: PropertyKey): number {
+  let addresses = fieldPointerAddresses.get(target)
+  if (addresses === undefined) {
+    addresses = new globalThis.Map<PropertyKey, number>()
+    fieldPointerAddresses.set(target, addresses)
+  }
+  let address = addresses.get(key)
+  if (address === undefined) {
+    address = nextPointerAddress * pointerAddressStride
+    nextPointerAddress++
+    addresses.set(key, address)
+  }
+  return address
+}
+
+function refPointer<T>(
+  ref: VarRef<T>,
+  address: () => number,
+): OwnedPointerHandle<T> {
+  return {
+    __goOwnedPointer: true,
+    __goAddress: address,
+    __goRef: () => ref,
+  }
 }
 
 /** Wrap a non-null T in a variable reference. */
@@ -19,7 +71,10 @@ export function varRef<T>(v: T): VarRef<T> {
   // We create a new object wrapper for every varRef call to ensure
   // distinct pointer identity, crucial for pointer comparisons (p1 == p2).
   // The __isVarRef marker allows the reflect system to identify this as a pointer type.
-  return { value: v, __isVarRef: true }
+  const ref: VarRef<T> = { value: v, __isVarRef: true }
+  ref.__goAddress = () => pointerAddress(ref)
+  ref.__goPointer = refPointer(ref, ref.__goAddress)
+  return ref
 }
 
 /** Create a variable reference to an object field. */
@@ -27,7 +82,8 @@ export function fieldRef<T extends object, K extends keyof T>(
   target: T,
   key: K,
 ): VarRef<T[K]> {
-  return {
+  const address = () => fieldPointerAddress(target, key)
+  const ref: VarRef<T[K]> = {
     get value(): T[K] {
       return target[key]
     },
@@ -35,7 +91,10 @@ export function fieldRef<T extends object, K extends keyof T>(
       target[key] = value
     },
     __isVarRef: true,
+    __goAddress: address,
   }
+  ref.__goPointer = refPointer(ref, address)
+  return ref
 }
 
 /** Check if a value is a VarRef (pointer) */
@@ -43,6 +102,30 @@ export function isVarRef(v: unknown): v is VarRef<unknown> {
   return v !== null && typeof v === 'object' && (v as any).__isVarRef === true
 }
 
+export function isOwnedPointerHandle(
+  value: unknown,
+): value is OwnedPointerHandle {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    (value as { __goOwnedPointer?: unknown }).__goOwnedPointer === true
+  )
+}
+
+export function ownedPointerFromRef<T>(
+  ref: VarRef<T>,
+): OwnedPointerHandle<T> | undefined {
+  return ref.__goPointer
+}
+
+export function ownedPointerAddress(pointer: OwnedPointerHandle): number {
+  return pointer.__goAddress()
+}
+
+export function ownedPointerRef<T>(pointer: OwnedPointerHandle<T>): VarRef<T> {
+  return pointer.__goRef()
+}
+
 /** Dereference a variable reference, throws on null → simulates Go panic. */
 export function unref<T>(b: VarRef<T>): T {
   if (b === null) {

package/gs/bytes/buffer.gs.ts

@@ -549,7 +549,7 @@ export class Buffer {
 	  new Buffer(),
 	  [{ name: "Bytes", args: [], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "AvailableBuffer", args: [], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "String", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }] }, { name: "empty", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "Len", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Cap", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Available", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Truncate", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Reset", args: [], returns: [] }, { name: "tryGrowByReslice", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "boolean" } }] }, { name: "grow", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Grow", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [] }, { name: "Write", args: [{ name: "p", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteString", args: [{ name: "s", type: { kind: $.TypeKind.Basic, name: "string" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadFrom", args: [{ name: "r", type: "Reader" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteTo", args: [{ name: "w", type: "Writer" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteByte", args: [{ name: "c", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteRune", args: [{ name: "r", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Read", args: [{ name: "p", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Next", args: [{ name: "n", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }] }, { name: "ReadByte", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadRune", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadRune", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadByte", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadBytes", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "readSlice", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadString", args: [{ name: "delim", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "string" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }],
 	  Buffer,
-	  {"buf": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "off": { kind: $.TypeKind.Basic, name: "number" }, "lastRead": "readOp"}
+	  [{ name: "buf", key: "buf", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "off", key: "off", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "lastRead", key: "lastRead", type: "readOp" }]
 	);
 }
 

package/gs/bytes/reader.gs.ts

@@ -221,7 +221,7 @@ export class Reader {
 	  new Reader(),
 	  [{ name: "Len", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Size", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }] }, { name: "Read", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadAt", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "off", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadByte", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadByte", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "ReadRune", args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "UnreadRune", args: [], returns: [{ type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Seek", args: [{ name: "offset", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "whence", type: { kind: $.TypeKind.Basic, name: "number" } }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "WriteTo", args: [{ name: "w", type: "Writer" }], returns: [{ type: { kind: $.TypeKind.Basic, name: "number" } }, { type: { kind: $.TypeKind.Interface, name: 'GoError', methods: [{ name: 'Error', args: [], returns: [{ type: { kind: $.TypeKind.Basic, name: 'string' } }] }] } }] }, { name: "Reset", args: [{ name: "b", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }], returns: [] }],
 	  Reader,
-	  {"s": { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } }, "i": { kind: $.TypeKind.Basic, name: "number" }, "prevRune": { kind: $.TypeKind.Basic, name: "number" }}
+	  [{ name: "s", key: "s", type: { kind: $.TypeKind.Slice, elemType: { kind: $.TypeKind.Basic, name: "number" } } }, { name: "i", key: "i", type: { kind: $.TypeKind.Basic, name: "number" } }, { name: "prevRune", key: "prevRune", type: { kind: $.TypeKind.Basic, name: "number" } }]
 	);
 }