goscript 0.0.61 → 0.0.63

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,
@@ -868,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.
@@ -882,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 }
   }
@@ -1061,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/builtin/varRef.ts

@@ -5,13 +5,19 @@
  *   var myVariable int // variable referenced
  *   myOtherVar := &myVariable
  */
-export type VarRef<T> = { value: T }
+export type VarRef<T> = { value: T; __isVarRef?: true }
 
 /** Wrap a non-null T in a variable reference. */
 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).
-  return { value: v }
+  // The __isVarRef marker allows the reflect system to identify this as a pointer type.
+  return { value: v, __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
 }
 
 /** Dereference a variable reference, throws on null → simulates Go panic. */

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/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

@@ -35,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,
   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 {