goscript 0.1.0 → 0.1.2

package/gs/builtin/type.ts

@@ -18,6 +18,7 @@ export enum TypeKind {
  */
 export interface BaseTypeInfo {
   name?: string
+  typeName?: string
   kind: TypeKind
   zeroValue?: any
 }
@@ -44,6 +45,7 @@ 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.
   tag?: string // The struct field tag (e.g., `json:"name,omitempty"`)
 }
 
@@ -203,6 +205,19 @@ export interface Comparable {
 
 // Registry to store runtime type information
 const typeRegistry = new Map<string, TypeInfo>()
+const duplicateTypeRegistry = new Map<string, TypeInfo[]>()
+
+function registerTypeInfo(name: string, typeInfo: TypeInfo): void {
+  const existing = typeRegistry.get(name)
+  if (existing && existing !== typeInfo) {
+    const candidates = duplicateTypeRegistry.get(name) ?? [existing]
+    if (!candidates.includes(typeInfo)) {
+      candidates.push(typeInfo)
+    }
+    duplicateTypeRegistry.set(name, candidates)
+  }
+  typeRegistry.set(name, typeInfo)
+}
 
 /**
  * Registers a struct type with the runtime type system.
@@ -229,10 +244,17 @@ export const registerStructType = (
     ctor,
     fields,
   }
-  typeRegistry.set(name, typeInfo)
+  registerTypeInfo(name, typeInfo)
   return typeInfo
 }
 
+function resolveZeroValue<T>(zeroValue: any): T {
+  if (typeof zeroValue === 'function') {
+    return zeroValue() as T
+  }
+  return zeroValue as T
+}
+
 /**
  * Registers an interface type with the runtime type system.
  *
@@ -252,7 +274,7 @@ export const registerInterfaceType = (
     zeroValue,
     methods,
   }
-  typeRegistry.set(name, typeInfo)
+  registerTypeInfo(name, typeInfo)
   return typeInfo
 }
 
@@ -293,6 +315,14 @@ function normalizeTypeInfo(info: string | TypeInfo): TypeInfo {
   return info
 }
 
+function typeInfoRuntimeName(info: TypeInfo): string | undefined {
+  return info.typeName || info.name
+}
+
+function goTypeMatchesTypeInfo(goType: string, info: TypeInfo): boolean {
+  return goType === typeInfoRuntimeName(info)
+}
+
 function compareOptionalTypeInfo(
   type1?: string | TypeInfo,
   type2?: string | TypeInfo,
@@ -500,13 +530,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),
-        )
+        const fieldTypeInfo =
+          isStructFieldInfo(fieldType) ? fieldType.type : fieldType
+        return matchesType(value[fieldName], normalizeTypeInfo(fieldTypeInfo))
       })
     }
 
@@ -526,11 +552,13 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
  */
 function matchesInterfaceType(value: any, info: TypeInfo): boolean {
   // Check basic conditions first
-  if (
-    !isInterfaceTypeInfo(info) ||
-    typeof value !== 'object' ||
-    value === null
-  ) {
+  if (!isInterfaceTypeInfo(info) || value === null || value === undefined) {
+    return false
+  }
+  if (info.methods.length === 0) {
+    return true
+  }
+  if (typeof value !== 'object') {
     return false
   }
 
@@ -667,9 +695,15 @@ function matchesMapType(value: any, info: TypeInfo): boolean {
  */
 function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
   // For slices and arrays, check if the value is an array and sample element types
-  if (!Array.isArray(value)) return false
   if (!isArrayTypeInfo(info) && !isSliceTypeInfo(info)) return false
 
+  if (value instanceof Uint8Array) {
+    if (isArrayTypeInfo(info) && value.length !== info.length) return false
+    return isNumberElementType(info.elemType)
+  }
+
+  if (!Array.isArray(value)) return false
+
   if (info.elemType) {
     const arr = value as any[]
     if (arr.length === 0) return true // Empty array matches any array type
@@ -690,6 +724,21 @@ function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
   return true
 }
 
+function isNumberElementType(typeInfo: string | TypeInfo | undefined): boolean {
+  if (typeInfo === undefined) return true
+  const info = normalizeTypeInfo(typeInfo)
+  return (
+    info.kind === TypeKind.Basic &&
+    (info.name === undefined ||
+      info.name === 'number' ||
+      info.name === 'int' ||
+      info.name === 'uint' ||
+      info.name === 'uint8' ||
+      info.name === 'byte' ||
+      info.name === 'float64')
+  )
+}
+
 // Symbol used to mark struct instances that represent values (not pointers)
 const STRUCT_VALUE_MARKER = Symbol('structValue')
 
@@ -701,6 +750,32 @@ export function markAsStructValue<T>(value: T): T {
   return value
 }
 
+export function cloneStructValue<T>(value: T): T {
+  const cloneable = value as T & {
+    __goscriptClone?: () => T
+    clone?: () => T
+  }
+  if (typeof cloneable.__goscriptClone === 'function') {
+    return cloneable.__goscriptClone()
+  }
+  if (typeof cloneable.clone === 'function') {
+    return cloneable.clone()
+  }
+  throw new Error('runtime error: value is not cloneable')
+}
+
+export function cloneArrayValue<T>(value: T): T {
+  if (value instanceof Uint8Array) {
+    const out = new Uint8Array(value.length)
+    out.set(value)
+    return out as T
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => cloneArrayValue(item)) as T
+  }
+  return value
+}
+
 // Check if a struct instance is marked as a value
 function isMarkedAsStructValue(value: any): boolean {
   return (
@@ -729,6 +804,10 @@ function matchesPointerType(value: any, info: TypeInfo): boolean {
 
   if (!isPointerTypeInfo(info)) return false
 
+  if (typeof value.__goType === 'string') {
+    return compareTypeStringWithTypeInfo(value.__goType, info)
+  }
+
   if (!info.elemType) return false
 
   let elem = info.elemType
@@ -854,6 +933,13 @@ function matchesType(value: any, info: TypeInfo): boolean {
   if (value === null || value === undefined) {
     return false
   }
+  if (
+    typeof value === 'object' &&
+    typeof value.__goType === 'string' &&
+    goTypeMatchesTypeInfo(value.__goType, info)
+  ) {
+    return true
+  }
 
   switch (info.kind) {
     case TypeKind.Basic:
@@ -1011,7 +1097,10 @@ export function typeAssert<T>(
 
   // Handle typed nil pointers (created by typedNil() for conversions like (*T)(nil))
   if (typeof value === 'object' && value !== null && value.__isTypedNil) {
-    if (isInterfaceTypeInfo(normalizedType) && matchesInterfaceType(value, normalizedType)) {
+    if (
+      isInterfaceTypeInfo(normalizedType) &&
+      matchesInterfaceType(value, normalizedType)
+    ) {
       return { value: value as T, ok: true }
     }
     // For typed nils, we need to compare the stored type with the expected type
@@ -1029,6 +1118,17 @@ export function typeAssert<T>(
   if (isPointerTypeInfo(normalizedType) && value === null) {
     return { value: null as unknown as T, ok: false }
   }
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof value.__goType === 'string' &&
+    goTypeMatchesTypeInfo(value.__goType, normalizedType)
+  ) {
+    if ('__goValue' in value) {
+      return { value: value.__goValue as T, ok: true }
+    }
+    return { value: value as T, ok: true }
+  }
 
   // Removed struct matching logic - struct types should use nominal matching
   // via matchesStructType in matchesType, not structural matching here
@@ -1040,9 +1140,9 @@ export function typeAssert<T>(
   ) {
     if (normalizedType.keyType || normalizedType.elemType) {
       const entries =
-        value instanceof Map
-          ? Array.from(value.entries())
-          : Object.entries(value)
+        value instanceof Map ?
+          Array.from(value.entries())
+        : Object.entries(value)
 
       if (entries.length === 0) {
         return { value: value as T, ok: true }
@@ -1080,29 +1180,26 @@ export function typeAssert<T>(
 
   const matches = matchesType(value, normalizedType)
   if (matches) {
-    // Special handling for pointer type assertions:
-    // If the value is a VarRef and we're asserting to a pointer type,
-    // return the inner value (value.value), not the VarRef object itself
-    if (
-      isPointerTypeInfo(normalizedType) &&
-      typeof value === 'object' &&
-      value !== null &&
-      'value' in value
-    ) {
-      return { value: value.value as T, ok: true }
-    }
     return { value: value as T, ok: true }
   }
 
+  if (typeof typeInfo === 'string') {
+    for (const candidate of duplicateTypeRegistry.get(typeInfo) ?? []) {
+      if (candidate !== normalizedType && matchesType(value, candidate)) {
+        return { value: value as T, ok: true }
+      }
+    }
+  }
+
   // If we get here, the assertion failed
   // For registered types, use the zero value from the registry
   if (typeof typeInfo === 'string') {
     const registeredType = typeRegistry.get(typeInfo)
     if (registeredType && registeredType.zeroValue !== undefined) {
-      return { value: registeredType.zeroValue as T, ok: false }
+      return { value: resolveZeroValue<T>(registeredType.zeroValue), ok: false }
     }
   } else if (normalizedType.zeroValue !== undefined) {
-    return { value: normalizedType.zeroValue as T, ok: false }
+    return { value: resolveZeroValue<T>(normalizedType.zeroValue), ok: false }
   }
 
   return { value: null as unknown as T, ok: false }
@@ -1166,7 +1263,7 @@ export function is(value: any, typeInfo: string | TypeInfo): boolean {
  */
 export interface TypeSwitchCase {
   types: (string | TypeInfo)[] // Array of types for this case (e.g., case int, string:)
-  body: (value?: any) => void // Function representing the case body. 'value' is the asserted value if applicable.
+  body: (value?: any) => any // Function representing the case body. 'value' is the asserted value if applicable.
 }
 
 /**
@@ -1180,16 +1277,15 @@ export interface TypeSwitchCase {
 export function typeSwitch(
   value: any,
   cases: TypeSwitchCase[],
-  defaultCase?: () => void,
-): void {
+  defaultCase?: () => any,
+): any {
   for (const caseObj of cases) {
     // For cases with multiple types (case T1, T2:), use $.is
     if (caseObj.types.length > 1) {
       const matchesAny = caseObj.types.some((typeInfo) => is(value, typeInfo))
       if (matchesAny) {
         // For multi-type cases, the case variable (if any) gets the original value
-        caseObj.body(value)
-        return // Found a match, exit switch
+        return caseObj.body(value)
       }
     } else if (caseObj.types.length === 1) {
       // For single-type cases (case T:), use $.typeAssert to get the typed value and ok status
@@ -1197,9 +1293,7 @@ export function typeSwitch(
       const { value: assertedValue, ok } = typeAssert(value, typeInfo)
       if (ok) {
         // Pass the asserted value to the case body function
-        caseObj.body(assertedValue)
-
-        return // Found a match, exit switch
+        return caseObj.body(assertedValue)
       }
     }
     // Note: Cases with 0 types are not valid in Go type switches
@@ -1207,7 +1301,7 @@ export function typeSwitch(
 
   // If no case matched and a default case exists, execute it
   if (defaultCase) {
-    defaultCase()
+    return defaultCase()
   }
 }
 
@@ -1228,6 +1322,13 @@ export function typedNil(typeName: string): any {
 
 export function interfaceValue<T>(value: unknown, typeName: string): T {
   if (value !== null && value !== undefined) {
+    if (typeof value === 'object') {
+      Object.defineProperty(value, '__goType', {
+        value: typeName,
+        writable: true,
+        configurable: true,
+      })
+    }
     return value as T
   }
 
@@ -1255,6 +1356,24 @@ export function interfaceValue<T>(value: unknown, typeName: string): T {
   return nilValue as T
 }
 
+export function namedValueInterfaceValue<T>(
+  value: unknown,
+  typeName: string,
+  methods: Record<string, (receiver: any, ...args: any[]) => any>,
+): T {
+  const boxed: any = {
+    __goType: typeName,
+    __goValue: value,
+    valueOf: () => value,
+    toString: () => String(value),
+    [Symbol.toPrimitive]: () => value as any,
+  }
+  for (const [name, method] of Object.entries(methods)) {
+    boxed[name] = (...args: any[]) => method(value, ...args)
+  }
+  return boxed as T
+}
+
 export function namedFunction<T>(fn: T, typeName: string): T {
   if (typeof fn !== 'function') {
     return fn

package/gs/builtin/varRef.ts

@@ -5,7 +5,14 @@
  *   var myVariable int // variable referenced
  *   myOtherVar := &myVariable
  */
-export type VarRef<T> = { value: T; __isVarRef?: true }
+export type VarRef<T> = {
+  value: T
+  __isVarRef?: true
+  __goType?: string
+  __goAddress?: () => number
+  __goCollection?: unknown
+  __goIndex?: number
+}
 
 /** Wrap a non-null T in a variable reference. */
 export function varRef<T>(v: T): VarRef<T> {
@@ -15,6 +22,22 @@ export function varRef<T>(v: T): VarRef<T> {
   return { value: v, __isVarRef: true }
 }
 
+/** Create a variable reference to an object field. */
+export function fieldRef<T extends object, K extends keyof T>(
+  target: T,
+  key: K,
+): VarRef<T[K]> {
+  return {
+    get value(): T[K] {
+      return target[key]
+    },
+    set value(value: T[K]) {
+      target[key] = value
+    },
+    __isVarRef: true,
+  }
+}
+
 /** Check if a value is a VarRef (pointer) */
 export function isVarRef(v: unknown): v is VarRef<unknown> {
   return v !== null && typeof v === 'object' && (v as any).__isVarRef === true
@@ -29,3 +52,19 @@ export function unref<T>(b: VarRef<T>): T {
   }
   return b.value
 }
+
+export function unsupportedPointerRef<T>(_value: unknown): VarRef<T> {
+  return {
+    get value(): T {
+      throw new Error(
+        'unsafe pointer dereference is not supported in JavaScript/TypeScript',
+      )
+    },
+    set value(_value: T) {
+      throw new Error(
+        'unsafe pointer dereference is not supported in JavaScript/TypeScript',
+      )
+    },
+    __isVarRef: true,
+  }
+}