goscript 0.0.60 → 0.0.62

package/gs/builtin/type.ts

@@ -39,6 +39,14 @@ export interface MethodSignature {
   returns: MethodArg[]
 }
 
+/**
+ * Information about a struct field including type and optional tag
+ */
+export interface StructFieldInfo {
+  type: TypeInfo | string // The field's type
+  tag?: string // The struct field tag (e.g., `json:"name,omitempty"`)
+}
+
 /**
  * Type information for struct types
  */
@@ -46,7 +54,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> // Field names and types for struct fields
+  fields: Record<string, TypeInfo | string | StructFieldInfo> // Field names and types for struct fields
 }
 
 /**
@@ -170,6 +178,21 @@ export function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeInfo {
   return info.kind === TypeKind.Channel
 }
 
+/**
+ * Type guard to check if a field value is a StructFieldInfo (has 'type' property)
+ * vs a direct TypeInfo or string
+ */
+export function isStructFieldInfo(
+  fieldValue: TypeInfo | string | StructFieldInfo,
+): fieldValue is StructFieldInfo {
+  return (
+    typeof fieldValue === 'object' &&
+    fieldValue !== null &&
+    'type' in fieldValue &&
+    !('kind' in fieldValue)
+  )
+}
+
 /**
  * Comparable interface for Go's comparable constraint.
  * Types that implement this can be compared with == and !=.
@@ -196,7 +219,7 @@ export const registerStructType = (
   zeroValue: any,
   methods: MethodSignature[],
   ctor: new (...args: any[]) => any,
-  fields: Record<string, TypeInfo | string> = {},
+  fields: Record<string, TypeInfo | string | StructFieldInfo> = {},
 ): StructTypeInfo => {
   const typeInfo: StructTypeInfo = {
     name,
@@ -233,6 +256,14 @@ export const registerInterfaceType = (
   return typeInfo
 }
 
+/**
+ * Gets a registered type by name from the type registry.
+ * Returns undefined if the type is not registered.
+ */
+export const getTypeByName = (name: string): TypeInfo | undefined => {
+  return typeRegistry.get(name)
+}
+
 /**
  * Represents the result of a type assertion.
  */
@@ -860,6 +891,110 @@ function matchesType(value: any, info: TypeInfo): boolean {
   }
 }
 
+/**
+ * Compares a Go type string (from typedNil) with a TypeInfo object.
+ * Used to check if a typed nil pointer matches a type assertion target.
+ *
+ * @param typeStr The Go type string (e.g., "*struct{Name string}")
+ * @param typeInfo The normalized TypeInfo to compare against
+ * @returns True if the types match, false otherwise
+ */
+function compareTypeStringWithTypeInfo(
+  typeStr: string,
+  typeInfo: TypeInfo,
+): boolean {
+  // For pointer types, strip the leading * and compare element types
+  if (isPointerTypeInfo(typeInfo)) {
+    if (!typeStr.startsWith('*')) {
+      return false
+    }
+    const elemStr = typeStr.slice(1)
+    const elemType = typeInfo.elemType
+    if (!elemType) {
+      return false
+    }
+    
+    // Handle struct types
+    if (elemStr.startsWith('struct{')) {
+      const elemTypeInfo = normalizeTypeInfo(elemType)
+      if (!isStructTypeInfo(elemTypeInfo)) {
+        return false
+      }
+      
+      // For anonymous structs, compare the type string representation
+      // Extract field definitions from the string
+      const fieldsMatch = elemStr.match(/^struct{(.+)}$/)
+      if (!fieldsMatch) {
+        return false
+      }
+      
+      const fieldStr = fieldsMatch[1]
+      // Parse fields like "Name string" or "X int; Y string"
+      const fieldParts = fieldStr.split(';').map(s => s.trim())
+      const parsedFields: Record<string, string> = {}
+      
+      for (const part of fieldParts) {
+        // Handle "Name string" format
+        const match = part.match(/^(\w+)\s+(.+)$/)
+        if (match) {
+          const [, fieldName, fieldType] = match
+          parsedFields[fieldName] = fieldType.trim()
+        }
+      }
+      
+      // Compare fields
+      const typeInfoFields = elemTypeInfo.fields || {}
+      const typeInfoFieldNames = Object.keys(typeInfoFields)
+      const parsedFieldNames = Object.keys(parsedFields)
+      
+      if (typeInfoFieldNames.length !== parsedFieldNames.length) {
+        return false
+      }
+      
+      // Check if all field names match and types are compatible
+      for (const fieldName of typeInfoFieldNames) {
+        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 parsedFieldType = parsedFields[fieldName]
+        
+        // Compare basic types
+        if (isBasicTypeInfo(typeInfoFieldType)) {
+          const expectedTypeName = typeInfoFieldType.name || ''
+          // Map Go types to TypeScript/runtime types
+          if (expectedTypeName === 'string' && parsedFieldType === 'string') {
+            continue
+          }
+          if ((expectedTypeName === 'int' || expectedTypeName === 'number') && 
+              (parsedFieldType === 'int' || parsedFieldType === 'number')) {
+            continue
+          }
+          return false
+        }
+      }
+      
+      return true
+    }
+    
+    // Handle named types
+    if (typeof elemType === 'string') {
+      return elemStr === elemType
+    }
+    if (elemType.name) {
+      return elemStr === elemType.name
+    }
+  }
+  
+  return false
+}
+
 /**
  * Performs a type assertion on a value against a specified type.
  * Returns an object containing the value (cast to type T) and a boolean indicating success.
@@ -874,6 +1009,21 @@ export function typeAssert<T>(
   typeInfo: string | TypeInfo,
 ): TypeAssertResult<T> {
   const normalizedType = normalizeTypeInfo(typeInfo)
+  
+  // Handle typed nil pointers (created by typedNil() for conversions like (*T)(nil))
+  if (typeof value === 'object' && value !== null && value.__isTypedNil) {
+    // For typed nils, we need to compare the stored type with the expected type
+    if (isPointerTypeInfo(normalizedType)) {
+      // Parse the stored type string and compare with expected type
+      const storedTypeStr = value.__goType as string
+      if (compareTypeStringWithTypeInfo(storedTypeStr, normalizedType)) {
+        return { value: null as unknown as T, ok: true }
+      }
+      return { value: null as unknown as T, ok: false }
+    }
+    return { value: null as unknown as T, ok: false }
+  }
+  
   if (isPointerTypeInfo(normalizedType) && value === null) {
     return { value: null as unknown as T, ok: true }
   }
@@ -1053,3 +1203,18 @@ export function typeSwitch(
     defaultCase()
   }
 }
+
+/**
+ * Creates a typed nil pointer with type metadata for reflection.
+ * This is used for type conversions like (*Interface)(nil) where we need
+ * to preserve the pointer type information even though the value is null.
+ * 
+ * @param typeName The full Go type name (e.g., "*main.Stringer")
+ * @returns An object that represents a typed nil with reflection metadata
+ */
+export function typedNil(typeName: string): any {
+  return Object.assign(Object.create(null), {
+    __goType: typeName,
+    __isTypedNil: true,
+  })
+}

package/gs/bytes/reader.gs.ts

@@ -224,7 +224,7 @@ export class Reader {
 }
 
 // NewReader returns a new [Reader] reading from b.
-export function NewReader(b: $.Bytes): Reader | null {
-	return new Reader({})
+export function NewReader(b: $.Bytes): Reader {
+	return new Reader({s: $.normalizeBytes(b), i: 0, prevRune: -1})
 }
 

package/gs/internal/byteorder/index.ts

@@ -38,3 +38,43 @@ export function LEUint64(b: $.Bytes): number {
   let high = LEUint32($.goSlice(b, 4, undefined))
   return low + high * 0x100000000
 }
+
+// Big Endian Put functions
+export function BEPutUint16(b: $.Bytes, v: number): void {
+  b![0] = (v >> 8) & 0xff
+  b![1] = v & 0xff
+}
+
+export function BEPutUint32(b: $.Bytes, v: number): void {
+  b![0] = (v >> 24) & 0xff
+  b![1] = (v >> 16) & 0xff
+  b![2] = (v >> 8) & 0xff
+  b![3] = v & 0xff
+}
+
+export function BEPutUint64(b: $.Bytes, v: number): void {
+  const high = Math.floor(v / 0x100000000)
+  const low = v >>> 0
+  BEPutUint32(b, high)
+  BEPutUint32($.goSlice(b, 4, undefined), low)
+}
+
+// Little Endian Put functions
+export function LEPutUint16(b: $.Bytes, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+}
+
+export function LEPutUint32(b: $.Bytes, v: number): void {
+  b![0] = v & 0xff
+  b![1] = (v >> 8) & 0xff
+  b![2] = (v >> 16) & 0xff
+  b![3] = (v >> 24) & 0xff
+}
+
+export function LEPutUint64(b: $.Bytes, v: number): void {
+  const low = v >>> 0
+  const high = Math.floor(v / 0x100000000)
+  LEPutUint32(b, low)
+  LEPutUint32($.goSlice(b, 4, undefined), high)
+}

package/gs/math/hypot.gs.test.ts

@@ -43,7 +43,9 @@ describe('Hypot', () => {
   it('should handle very large values without overflow', () => {
     const large = 1e150
     const result = Hypot(large, large)
-    expect(result).toBeCloseTo(large * Math.sqrt(2), 5)
+    const expected = large * Math.sqrt(2)
+    // Use relative tolerance for very large numbers
+    expect(Math.abs(result - expected) / expected).toBeLessThan(1e-10)
     expect(IsInf(result, 0)).toBe(false)
   })
 

package/gs/math/pow10.gs.test.ts

@@ -26,10 +26,11 @@ describe('Pow10', () => {
   })
 
   it('should handle large positive exponents', () => {
-    expect(Pow10(100)).toBe(1e100)
-    expect(Pow10(200)).toBe(1e200)
-    expect(Pow10(300)).toBe(1e300)
-    expect(Pow10(308)).toBe(1e308)
+    // Use relative tolerance for very large numbers
+    expect(Math.abs(Pow10(100) - 1e100) / 1e100).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(200) - 1e200) / 1e200).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(300) - 1e300) / 1e300).toBeLessThan(1e-10)
+    expect(Math.abs(Pow10(308) - 1e308) / 1e308).toBeLessThan(1e-10)
     expect(Pow10(309)).toBe(Number.POSITIVE_INFINITY)
     expect(Pow10(400)).toBe(Number.POSITIVE_INFINITY)
   })

package/gs/reflect/index.ts

@@ -1,6 +1,7 @@
 // Export the main reflect functions organized like Go stdlib
 export {
   TypeOf,
+  TypeFor,
   ValueOf,
   Value,
   Kind_String,
@@ -14,6 +15,7 @@ export {
   RecvDir,
   SendDir,
   BothDir,
+  getInterfaceTypeByName,
 } from './type.js'
 export type { Type, ChanDir, Kind } from './type.js'
 export { DeepEqual } from './deepequal.js'
@@ -33,19 +35,20 @@ export { Swapper } from './swapper.js'
 // Export new types and constants
 export {
   StructTag,
+  StructTag_Get,
+  StructField,
   ValueError,
-  SelectDir,
   SelectSend,
   SelectRecv,
   SelectDefault,
+  SelectCase,
   bitVector,
 } from './types.js'
 export type {
   uintptr,
   Pointer,
-  StructField,
   Method,
-  SelectCase,
+  SelectDir,
   SliceHeader,
   StringHeader,
   MapIter,

package/gs/reflect/map.test.ts

@@ -11,20 +11,21 @@ describe('MapIter', () => {
     const iter = new MapIter<string, number>(map)
 
     expect(iter.current?.done === false).toBe(true)
-    expect(iter.Key()).toBe('one')
-    expect(iter.Value()).toBe(1)
+    // Key() and Value() return reflect.Value objects now
+    expect(iter.Key().Interface()).toBe('one')
+    expect(iter.Value().Interface()).toBe(1)
 
     expect(iter.Next()).toBe(true)
     expect(iter.current?.done === false).toBe(true)
-    expect(typeof iter.Key()).toBe('string')
-    expect(typeof iter.Value()).toBe('number')
+    expect(iter.Key().Kind()).toBe(24) // String kind
+    expect(iter.Value().Kind()).toBe(2) // Int kind
 
     const newMap = new Map<string, number>()
     newMap.set('reset', 100)
     iter.Reset(newMap)
 
     expect(iter.current?.done === false).toBe(true)
-    expect(iter.Key()).toBe('reset')
-    expect(iter.Value()).toBe(100)
+    expect(iter.Key().Interface()).toBe('reset')
+    expect(iter.Value().Interface()).toBe(100)
   })
 })

package/gs/reflect/map.ts

@@ -1,4 +1,4 @@
-import { Type, Kind, Value, Map as MapKind } from './type.js'
+import { Type, Kind, Value, Map as MapKind, StructField, TypeOf } from './type.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -20,26 +20,66 @@ class MapType implements Type {
     return MapKind // Map kind
   }
 
+  public Name(): string {
+    return '' // Map types are unnamed composite types
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
 
-  public Elem(): Type | null {
+  public Elem(): Type {
     return this._elemType
   }
 
-  public Key(): Type | null {
+  public Key(): Type {
     return this._keyType
   }
 
   public NumField(): number {
     return 0
   }
+
+  public Field(_i: number): StructField {
+    throw new Error('reflect: Field of non-struct type map')
+  }
+
+  public Implements(u: Type | null): boolean {
+    if (!u) {
+      return false
+    }
+    if (u.Kind() !== 20) {
+      // Interface kind
+      throw new Error('reflect: non-interface type passed to Type.Implements')
+    }
+    return false
+  }
+
+  public OverflowInt(_x: number): boolean {
+    throw new Error('reflect: OverflowInt of non-integer type map')
+  }
+
+  public OverflowUint(_x: number): boolean {
+    throw new Error('reflect: OverflowUint of non-integer type map')
+  }
+
+  public OverflowFloat(_x: number): boolean {
+    throw new Error('reflect: OverflowFloat of non-float type map')
+  }
+
+  public NumMethod(): number {
+    return 0
+  }
+
+  public Bits(): number {
+    throw new Error('reflect: Bits of non-sized type map')
+  }
 }
 
 /**
  * MapIter provides an iterator interface for Go maps.
  * It wraps a JavaScript Map iterator and provides methods to iterate over key-value pairs.
+ * Returns reflect.Value for Key() and Value() to match Go's reflect.MapIter.
  * @template K - The type of keys in the map
  * @template V - The type of values in the map
  */
@@ -57,12 +97,14 @@ export class MapIter<K = unknown, V = unknown> {
     return !this.current.done
   }
 
-  public Key(): K | null {
-    return this.current?.value?.[0] ?? null
+  public Key(): Value {
+    const rawKey = this.current?.value?.[0] ?? null
+    return new Value(rawKey, TypeOf(rawKey))
   }
 
-  public Value(): V | null {
-    return this.current?.value?.[1] ?? null
+  public Value(): Value {
+    const rawVal = this.current?.value?.[1] ?? null
+    return new Value(rawVal, TypeOf(rawVal))
   }
 
   public Reset(m: Map<K, V>): void {