goscript 0.1.1 → 0.1.2

package/gs/reflect/iter.ts

@@ -11,7 +11,7 @@ export function rangeNum<T extends number | uintptr, N extends number | number>(
 
   // if the iteration value type is define by
   // type T built-in type.
-  return (_yield: ((v: Value) => boolean) | null): void => {
+  return async (_yield: ((v: Value) => iter.YieldResult) | null): Promise<void> => {
     let convert = t!.PkgPath!() != ''
     // cannot use range T(v) because no core type.
 
@@ -24,7 +24,7 @@ export function rangeNum<T extends number | uintptr, N extends number | number>(
       if (convert) {
         tmp = tmp.Convert(t).clone()
       }
-      if (!_yield!(tmp)) {
+      if (!await _yield!(tmp)) {
         return
       }
     }

package/gs/reflect/map.test.ts

@@ -1,6 +1,5 @@
 import { describe, it, expect } from 'vitest'
-import { MapIter } from './map.js'
-import { ValueOf } from './type.js'
+import { AppendSlice, MakeMapWithSize, MapIter, MapOf, TypeOf, ValueOf } from './index.js'
 
 describe('MapIter', () => {
   it('should iterate over map entries with proper typing', () => {
@@ -48,3 +47,26 @@ describe('Value.MapKeys', () => {
     expect(ValueOf(emptyMap).MapKeys()).toEqual([])
   })
 })
+
+describe('reflect compatibility surface', () => {
+  it('constructs maps, ranges entries, and looks up values', () => {
+    const typ = MapOf(TypeOf(''), TypeOf(0))
+    const mapValue = MakeMapWithSize(typ, 4)
+    const raw = mapValue.Interface() as Map<string, number>
+    raw.set('alpha', 1)
+
+    const iter = mapValue.MapRange()
+
+    expect(iter?.Key().Interface()).toBe('alpha')
+    expect(mapValue.MapIndex(ValueOf('alpha')).Interface()).toBe(1)
+    expect(mapValue.Type().Comparable()).toBe(false)
+    expect(TypeOf('alpha').Comparable()).toBe(true)
+  })
+
+  it('slices and appends slice values', () => {
+    const sliced = ValueOf([1, 2, 3, 4]).Slice(1, 3)
+    const appended = AppendSlice(sliced, ValueOf([5, 6]))
+
+    expect(appended.Interface()).toEqual([2, 3, 5, 6])
+  })
+})

package/gs/reflect/map.ts

@@ -6,6 +6,7 @@ import {
   StructField,
   TypeOf,
 } from './type.js'
+import { Method } from './types.js'
 
 // Simple MapOf implementation using JavaScript Map
 export function MapOf(key: Type, elem: Type): Type {
@@ -27,10 +28,18 @@ class MapType implements Type {
     return MapKind // Map kind
   }
 
+  public Comparable(): boolean {
+    return false
+  }
+
   public Name(): string {
     return '' // Map types are unnamed composite types
   }
 
+  public PkgPath(): string {
+    return ''
+  }
+
   public Size(): number {
     return 8 // pointer size
   }
@@ -51,6 +60,16 @@ class MapType implements Type {
     throw new Error('reflect: Field of non-struct type map')
   }
 
+  public FieldByName(_name: string): [StructField, boolean] {
+    throw new Error('reflect: FieldByName of non-struct type map')
+  }
+
+  public FieldByNameFunc(
+    _match: (name: string) => boolean,
+  ): [StructField, boolean] {
+    throw new Error('reflect: FieldByNameFunc of non-struct type map')
+  }
+
   public Implements(u: Type | null): boolean {
     if (!u) {
       return false
@@ -62,6 +81,10 @@ class MapType implements Type {
     return false
   }
 
+  public AssignableTo(u: Type | null): boolean {
+    return u != null && this.String() === u.String()
+  }
+
   public OverflowInt(_x: number): boolean {
     throw new Error('reflect: OverflowInt of non-integer type map')
   }
@@ -78,6 +101,18 @@ class MapType implements Type {
     return 0
   }
 
+  public MethodByName(_name: string): [Method, boolean] {
+    return [
+      {
+        Name: '',
+        Type: TypeOf(null),
+        Func: () => undefined,
+        Index: 0,
+      },
+      false,
+    ]
+  }
+
   public Len(): number {
     throw new Error('reflect: Len of non-array type map')
   }