goscript 0.0.36 → 0.0.38

package/gs/reflect/deepequal.ts

@@ -0,0 +1,154 @@
+// DeepEqual reports whether x and y are "deeply equal," defined as follows.
+// Two values of identical type are deeply equal if one of the following cases applies.
+// Values of distinct types are never deeply equal.
+//
+// Array values are deeply equal when their corresponding elements are deeply equal.
+//
+// Struct values are deeply equal if their corresponding fields,
+// both exported and unexported, are deeply equal.
+//
+// Func values are deeply equal if both are nil; otherwise they are not deeply equal.
+//
+// Interface values are deeply equal if they hold deeply equal concrete values.
+//
+// Map values are deeply equal when all of the following are true:
+// they are both nil or both non-nil, they have the same length,
+// and either they are the same map object or their corresponding keys
+// (matched using Go equality) map to deeply equal values.
+//
+// Pointer values are deeply equal if they are equal using Go's == operator
+// or if they point to deeply equal values.
+//
+// Slice values are deeply equal when all of the following are true:
+// they are both nil or both non-nil, they have the same length,
+// and either they point to the same initial entry of the same underlying array
+// (that is, &x[0] == &y[0]) or their corresponding elements (up to length) are deeply equal.
+// Note that a non-nil empty slice and a nil slice (for example, []byte{} and []byte(nil))
+// are not deeply equal.
+//
+// Other values - numbers, bools, strings, and channels - are deeply equal
+// if they are equal using Go's == operator.
+//
+// In general DeepEqual is a recursive relaxation of Go's == operator.
+// However, this idea is impossible to implement without some inconsistency.
+// Specifically, it is possible for a value to be unequal to itself,
+// either because it is of func type (uncomparable in general)
+// or because it is a floating-point NaN value (not equal to itself in floating-point comparison),
+// or because it is an array, struct, or interface containing
+// such a value.
+// On the other hand, pointer values are always equal to themselves,
+// even if they point at or contain such problematic values,
+// because they compare equal using Go's == operator, and that
+// is a sufficient condition to be deeply equal, regardless of content.
+// DeepEqual has been defined so that the same short-cut applies
+// to slices and maps: if x and y are the same slice or the same map,
+// they are deeply equal regardless of content.
+//
+// As DeepEqual traverses the data values it may find a cycle. The
+// second and subsequent times that DeepEqual compares two pointer
+// values that have been compared before, it treats the values as
+// equal rather than examining the values to which they point.
+// This ensures that DeepEqual terminates.
+export function DeepEqual(x: null | any, y: null | any): boolean {
+  // Handle null/undefined cases
+  if (x === y) {
+    return true
+  }
+
+  if (x === null || y === null || x === undefined || y === undefined) {
+    return x === y
+  }
+
+  // Check for identical references first
+  if (x === y) {
+    return true
+  }
+
+  // Different types are never equal
+  if (typeof x !== typeof y) {
+    return false
+  }
+
+  // Handle arrays (including GoScript slices)
+  if (globalThis.Array.isArray(x) && globalThis.Array.isArray(y)) {
+    if (x.length !== y.length) {
+      return false
+    }
+    for (let i = 0; i < x.length; i++) {
+      if (!DeepEqual(x[i], y[i])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  // Handle GoScript slice objects with __meta__ structure
+  if (x && y && typeof x === 'object' && typeof y === 'object') {
+    // Check if both are GoScript slices
+    if ('__meta__' in x && '__meta__' in y) {
+      const xMeta = (
+        x as { __meta__?: { backing?: unknown[]; length?: number } }
+      ).__meta__
+      const yMeta = (
+        y as { __meta__?: { backing?: unknown[]; length?: number } }
+      ).__meta__
+
+      if (
+        xMeta &&
+        yMeta &&
+        'backing' in xMeta &&
+        'backing' in yMeta &&
+        'length' in xMeta &&
+        'length' in yMeta &&
+        globalThis.Array.isArray(xMeta.backing) &&
+        globalThis.Array.isArray(yMeta.backing) &&
+        typeof xMeta.length === 'number' &&
+        typeof yMeta.length === 'number'
+      ) {
+        // Compare lengths
+        if (xMeta.length !== yMeta.length) {
+          return false
+        }
+
+        // Compare elements
+        for (let i = 0; i < xMeta.length; i++) {
+          if (!DeepEqual(xMeta.backing[i], yMeta.backing[i])) {
+            return false
+          }
+        }
+        return true
+      }
+    }
+  }
+
+  // Handle Maps
+  if (x instanceof globalThis.Map && y instanceof globalThis.Map) {
+    if (x.size !== y.size) {
+      return false
+    }
+    for (const [key, value] of x) {
+      if (!y.has(key) || !DeepEqual(value, y.get(key))) {
+        return false
+      }
+    }
+    return true
+  }
+
+  // Handle objects (structs)
+  if (typeof x === 'object' && typeof y === 'object') {
+    const keysX = Object.keys(x)
+    const keysY = Object.keys(y)
+    if (keysX.length !== keysY.length) {
+      return false
+    }
+    for (const key of keysX) {
+      if (!keysY.includes(key) || !DeepEqual(x[key], y[key])) {
+        return false
+      }
+    }
+    return true
+  }
+
+  // For primitive values, use direct comparison
+  return x === y
+}

package/gs/reflect/function-types.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import { TypeOf } from './type.js'
+
+describe('Function Type Detection', () => {
+  it('should detect regular function types', () => {
+    const regularFunc = function (x: number, y: number) {
+      return x + y
+    }
+    const type = TypeOf(regularFunc)
+    expect(type.String()).toMatch(/^func/)
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should detect GoScript typed functions with __goTypeName', () => {
+    // Test Greeter function type
+    const greetFunc = function (name: string) {
+      return 'Hello, ' + name
+    }
+    Object.assign(greetFunc, { __goTypeName: 'Greeter' })
+    const greetType = TypeOf(greetFunc)
+    expect(greetType.String()).toBe('func(string) string')
+    expect(greetType.Kind().String()).toBe('func')
+
+    // Test Adder function type
+    const addFunc = function (a: number, b: number) {
+      return a + b
+    }
+    Object.assign(addFunc, { __goTypeName: 'Adder' })
+    const addType = TypeOf(addFunc)
+    expect(addType.String()).toBe('func(int, int) int')
+    expect(addType.Kind().String()).toBe('func')
+  })
+
+  it('should detect functions with full __typeInfo metadata', () => {
+    const complexFunc = function (x: number, y: number) {
+      return x + y
+    }
+    Object.assign(complexFunc, {
+      __goTypeName: 'MyFunc',
+      __typeInfo: {
+        kind: 'Function',
+        params: [
+          { kind: 'Basic', name: 'int' },
+          { kind: 'Basic', name: 'int' },
+        ],
+        results: [{ kind: 'Basic', name: 'int' }],
+      },
+    })
+
+    const type = TypeOf(complexFunc)
+    expect(type.String()).toBe('func(int, int) int')
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should handle functions with multiple return types', () => {
+    const multiReturnFunc = function () {
+      return [1, 'test']
+    }
+    Object.assign(multiReturnFunc, {
+      __goTypeName: 'MultiReturn',
+      __typeInfo: {
+        kind: 'Function',
+        params: [],
+        results: [
+          { kind: 'Basic', name: 'int' },
+          { kind: 'Basic', name: 'string' },
+        ],
+      },
+    })
+
+    const type = TypeOf(multiReturnFunc)
+    expect(type.String()).toBe('func() (int, string)')
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should handle functions with no parameters', () => {
+    const noParamFunc = function () {
+      return 42
+    }
+    Object.assign(noParamFunc, {
+      __goTypeName: 'NoParam',
+      __typeInfo: {
+        kind: 'Function',
+        params: [],
+        results: [{ kind: 'Basic', name: 'int' }],
+      },
+    })
+
+    const type = TypeOf(noParamFunc)
+    expect(type.String()).toBe('func() int')
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should handle functions with no return type', () => {
+    const voidFunc = function (x: number) {
+      console.log(x)
+    }
+    Object.assign(voidFunc, {
+      __goTypeName: 'VoidFunc',
+      __typeInfo: {
+        kind: 'Function',
+        params: [{ kind: 'Basic', name: 'int' }],
+        results: [],
+      },
+    })
+
+    const type = TypeOf(voidFunc)
+    expect(type.String()).toBe('func(int)')
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should fallback to generic func for unknown typed functions', () => {
+    const unknownFunc = function (x: any) {
+      return x
+    }
+    Object.assign(unknownFunc, { __goTypeName: 'UnknownType' })
+
+    const type = TypeOf(unknownFunc)
+    expect(type.String()).toBe('func')
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should handle arrow functions', () => {
+    const arrowFunc = (x: number) => x * 2
+    const type = TypeOf(arrowFunc)
+    expect(type.String()).toMatch(/^func/)
+    expect(type.Kind().String()).toBe('func')
+  })
+
+  it('should detect functions that return values vs void functions', () => {
+    // Function with return
+    const returningFunc = function (x: number) {
+      return x * 2
+    }
+    const returnType = TypeOf(returningFunc)
+    expect(returnType.String()).toMatch(/func.*any$/)
+
+    // Function without return (void)
+    const voidFunc = function (x: number) {
+      console.log(x)
+    }
+    const voidType = TypeOf(voidFunc)
+    // Should not have return type suffix
+    expect(voidType.String()).not.toMatch(/func.*any$/)
+  })
+})

package/gs/reflect/godoc.txt

@@ -0,0 +1,67 @@
+package reflect // import "reflect"
+
+Package reflect implements run-time reflection, allowing a program to manipulate
+objects with arbitrary types. The typical use is to take a value with static
+type interface{} and extract its dynamic type information by calling TypeOf,
+which returns a Type.
+
+A call to ValueOf returns a Value representing the run-time data. Zero takes a
+Type and returns a Value representing a zero value for that type.
+
+See "The Laws of Reflection" for an introduction to reflection in Go:
+https://golang.org/doc/articles/laws_of_reflection.html
+
+const Ptr = Pointer
+func Copy(dst, src Value) int
+func DeepEqual(x, y any) bool
+func Select(cases []SelectCase) (chosen int, recv Value, recvOK bool)
+func Swapper(slice any) func(i, j int)
+type ChanDir int
+    const RecvDir ChanDir = 1 << iota ...
+type Kind uint
+    const Invalid Kind = iota ...
+type MapIter struct{ ... }
+type Method struct{ ... }
+type SelectCase struct{ ... }
+type SelectDir int
+    const SelectSend SelectDir ...
+type SliceHeader struct{ ... }
+type StringHeader struct{ ... }
+type StructField struct{ ... }
+    func VisibleFields(t Type) []StructField
+type StructTag string
+type Type interface{ ... }
+    func ArrayOf(length int, elem Type) Type
+    func ChanOf(dir ChanDir, t Type) Type
+    func FuncOf(in, out []Type, variadic bool) Type
+    func MapOf(key, elem Type) Type
+    func PointerTo(t Type) Type
+    func PtrTo(t Type) Type
+    func SliceOf(t Type) Type
+    func StructOf(fields []StructField) Type
+    func TypeFor[T any]() Type
+    func TypeOf(i any) Type
+type Value struct{ ... }
+    func Append(s Value, x ...Value) Value
+    func AppendSlice(s, t Value) Value
+    func Indirect(v Value) Value
+    func MakeChan(typ Type, buffer int) Value
+    func MakeFunc(typ Type, fn func(args []Value) (results []Value)) Value
+    func MakeMap(typ Type) Value
+    func MakeMapWithSize(typ Type, n int) Value
+    func MakeSlice(typ Type, len, cap int) Value
+    func New(typ Type) Value
+    func NewAt(typ Type, p unsafe.Pointer) Value
+    func SliceAt(typ Type, p unsafe.Pointer, n int) Value
+    func ValueOf(i any) Value
+    func Zero(typ Type) Value
+type ValueError struct{ ... }
+
+BUG: FieldByName and related functions consider struct field names to be equal
+if the names are equal, even if they are unexported names originating
+in different packages. The practical effect of this is that the result of
+t.FieldByName("x") is not well defined if the struct type t contains
+multiple fields named x (embedded from different packages).
+FieldByName may return one of the fields named x or may report that there are none.
+See https://golang.org/issue/4876 for more details.
+

package/gs/reflect/index.ts

@@ -0,0 +1,83 @@
+// Export the main reflect functions organized like Go stdlib
+export {
+  TypeOf,
+  ValueOf,
+  Value,
+  Kind,
+  ArrayOf,
+  SliceOf,
+  PointerTo,
+  PtrTo,
+  MapOf,
+  ChanOf,
+} from './type'
+export type { Type } from './type'
+export { DeepEqual } from './deepequal'
+export {
+  Zero,
+  Copy,
+  Indirect,
+  New,
+  MakeSlice,
+  MakeMap,
+  Append,
+  MakeChan,
+  Select,
+} from './value'
+export { Swapper } from './swapper'
+
+// Export new types and constants
+export {
+  ChanDir,
+  RecvDir,
+  SendDir,
+  BothDir,
+  StructTag,
+  ValueError,
+  SelectDir,
+  SelectSend,
+  SelectRecv,
+  SelectDefault,
+  bitVector,
+} from './types'
+export type {
+  uintptr,
+  Pointer,
+  StructField,
+  Method,
+  SelectCase,
+  SliceHeader,
+  StringHeader,
+  MapIter,
+} from './types'
+
+// Export kind constants
+export {
+  Invalid,
+  Bool,
+  Int,
+  Int8,
+  Int16,
+  Int32,
+  Int64,
+  Uint,
+  Uint8,
+  Uint16,
+  Uint32,
+  Uint64,
+  Uintptr,
+  Float32,
+  Float64,
+  Complex64,
+  Complex128,
+  Array,
+  Chan,
+  Func,
+  Interface,
+  Map,
+  Ptr,
+  Slice,
+  String,
+  Struct,
+  UnsafePointer,
+} from './type'

package/gs/reflect/iter.ts

@@ -0,0 +1,44 @@
+import { Type, Value } from './type.js'
+import { uintptr } from './types.js'
+import { ValueOf } from './value.js'
+
+import * as iter from '@goscript/iter/index.js'
+
+export function rangeNum<
+  T extends
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | number
+    | uintptr,
+  N extends number | number,
+>(num: N, t: Type): iter.Seq<Value> {
+  // cannot use range T(v) because no core type.
+
+  // if the iteration value type is define by
+  // type T built-in type.
+  return (_yield: ((v: Value) => boolean) | null): void => {
+    let convert = t!.PkgPath!() != ''
+    // cannot use range T(v) because no core type.
+
+    // if the iteration value type is define by
+    // type T built-in type.
+    for (let i = 0 as unknown as T; i < (num as unknown as T); i++) {
+      let tmp = ValueOf(i).clone()
+      // if the iteration value type is define by
+      // type T built-in type.
+      if (convert) {
+        tmp = tmp.Convert(t).clone()
+      }
+      if (!_yield!(tmp)) {
+        return
+      }
+    }
+  }
+}

package/gs/reflect/map.ts

@@ -0,0 +1,81 @@
+import { Type, Kind, Value } from './type.js'
+
+// Simple MapOf implementation using JavaScript Map
+export function MapOf(key: Type, elem: Type): Type {
+  return new MapType(key, elem)
+}
+
+// Simple map type implementation
+class MapType implements Type {
+  constructor(
+    private _keyType: Type,
+    private _elemType: Type,
+  ) {}
+
+  public String(): string {
+    return `map[${this._keyType.String()}]${this._elemType.String()}`
+  }
+
+  public Kind(): Kind {
+    return new Kind(21) // Map kind
+  }
+
+  public Size(): number {
+    return 8 // pointer size
+  }
+
+  public Elem(): Type | null {
+    return this._elemType
+  }
+
+  public Key(): Type | null {
+    return this._keyType
+  }
+
+  public NumField(): number {
+    return 0
+  }
+}
+
+// Simple map iterator using JavaScript Map
+export class MapIter {
+  private iterator: Iterator<[any, any]>
+  private currentEntry: IteratorResult<[any, any]> | null = null
+
+  constructor(private map: Map<any, any>) {
+    this.iterator = map.entries()
+    this.Next()
+  }
+
+  public Next(): boolean {
+    this.currentEntry = this.iterator.next()
+    return !this.currentEntry.done
+  }
+
+  public Key(): any {
+    return this.currentEntry?.value?.[0]
+  }
+
+  public Value(): any {
+    return this.currentEntry?.value?.[1]
+  }
+
+  public Reset(m: any): void {
+    if (m instanceof Map) {
+      this.map = m
+      this.iterator = m.entries()
+      this.Next()
+    }
+  }
+}
+
+// Helper functions for map operations
+export function MakeMap(typ: Type): Value {
+  const map = new Map()
+  return new Value(map, typ)
+}
+
+export function MakeMapWithSize(typ: Type, _n: number): Value {
+  // JavaScript Map doesn't have initial size, so we ignore n
+  return MakeMap(typ)
+}

package/gs/reflect/swapper.ts

@@ -0,0 +1,52 @@
+import { ReflectValue } from './types'
+
+// Swapper returns a function that swaps the elements in the provided slice.
+// Swapper panics if the provided interface is not a slice.
+export function Swapper(slice: ReflectValue): (i: number, j: number) => void {
+  let actualArray: unknown[] | null = null
+
+  // Try to extract the underlying array
+  if (Array.isArray(slice)) {
+    actualArray = slice
+  } else if (slice && typeof slice === 'object' && '__meta__' in slice) {
+    // GoScript slice object
+    const meta = (slice as { __meta__?: { backing?: unknown[] } }).__meta__
+    if (meta && meta.backing && Array.isArray(meta.backing)) {
+      actualArray = meta.backing
+    }
+  }
+
+  if (!actualArray) {
+    // Return a no-op function if we can't extract an array
+    return () => {}
+  }
+
+  // Fast path for slices of size 0 and 1. Nothing to swap.
+  switch (actualArray.length) {
+    case 0:
+      return (_i: number, _j: number): void => {
+        throw new Error('reflect: slice index out of range')
+      }
+    case 1:
+      return (i: number, j: number): void => {
+        if (i !== 0 || j !== 0) {
+          throw new Error('reflect: slice index out of range')
+        }
+      }
+  }
+
+  // Return the swapper function
+  return (i: number, j: number) => {
+    if (
+      actualArray &&
+      i >= 0 &&
+      j >= 0 &&
+      i < actualArray.length &&
+      j < actualArray.length
+    ) {
+      const temp = actualArray[i]
+      actualArray[i] = actualArray[j]
+      actualArray[j] = temp
+    }
+  }
+}