goscript 0.0.16 → 0.0.18

package/LICENSE

@@ -1,7 +1,7 @@
 MIT License
 
 Copyright (c) 2024-2025 Aperture Robotics, LLC.
-Copyright (c) 2019-2025 Christian Stewart
+Copyright (c) 2019-2025 Christian Stewart <christian@cjs.zip>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1,11 +1,13 @@
 # GoScript
 
-[![GoDoc Widget]][GoDoc] [![Go Report Card Widget]][Go Report Card]
+[![GoDoc Widget]][GoDoc] [![Go Report Card Widget]][Go Report Card] [![DeepWiki Widget]][DeepWiki]
 
 [GoDoc]: https://godoc.org/github.com/aperturerobotics/goscript
 [GoDoc Widget]: https://godoc.org/github.com/aperturerobotics/goscript?status.svg
 [Go Report Card Widget]: https://goreportcard.com/badge/github.com/aperturerobotics/goscript
 [Go Report Card]: https://goreportcard.com/report/github.com/aperturerobotics/goscript
+[DeepWiki Widget]: https://img.shields.io/badge/DeepWiki-aperturerobotics%2Fgoscript-blue.svg?logo=data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAACwAAAAyCAYAAAAnWDnqAAAAAXNSR0IArs4c6QAAA05JREFUaEPtmUtyEzEQhtWTQyQLHNak2AB7ZnyXZMEjXMGeK/AIi+QuHrMnbChYY7MIh8g01fJoopFb0uhhEqqcbWTp06/uv1saEDv4O3n3dV60RfP947Mm9/SQc0ICFQgzfc4CYZoTPAswgSJCCUJUnAAoRHOAUOcATwbmVLWdGoH//PB8mnKqScAhsD0kYP3j/Yt5LPQe2KvcXmGvRHcDnpxfL2zOYJ1mFwrryWTz0advv1Ut4CJgf5uhDuDj5eUcAUoahrdY/56ebRWeraTjMt/00Sh3UDtjgHtQNHwcRGOC98BJEAEymycmYcWwOprTgcB6VZ5JK5TAJ+fXGLBm3FDAmn6oPPjR4rKCAoJCal2eAiQp2x0vxTPB3ALO2CRkwmDy5WohzBDwSEFKRwPbknEggCPB/imwrycgxX2NzoMCHhPkDwqYMr9tRcP5qNrMZHkVnOjRMWwLCcr8ohBVb1OMjxLwGCvjTikrsBOiA6fNyCrm8V1rP93iVPpwaE+gO0SsWmPiXB+jikdf6SizrT5qKasx5j8ABbHpFTx+vFXp9EnYQmLx02h1QTTrl6eDqxLnGjporxl3NL3agEvXdT0WmEost648sQOYAeJS9Q7bfUVoMGnjo4AZdUMQku50McDcMWcBPvr0SzbTAFDfvJqwLzgxwATnCgnp4wDl6Aa+Ax283gghmj+vj7feE2KBBRMW3FzOpLOADl0Isb5587h/U4gGvkt5v60Z1VLG8BhYjbzRwyQZemwAd6cCR5/XFWLYZRIMpX39AR0tjaGGiGzLVyhse5C9RKC6ai42ppWPKiBagOvaYk8lO7DajerabOZP46Lby5wKjw1HCRx7p9sVMOWGzb/vA1hwiWc6jm3MvQDTogQkiqIhJV0nBQBTU+3okKCFDy9WwferkHjtxib7t3xIUQtHxnIwtx4mpg26/HfwVNVDb4oI9RHmx5WGelRVlrtiw43zboCLaxv46AZeB3IlTkwouebTr1y2NjSpHz68WNFjHvupy3q8TFn3Hos2IAk4Ju5dCo8B3wP7VPr/FGaKiG+T+v+TQqIrOqMTL1VdWV1DdmcbO8KXBz6esmYWYKPwDL5b5FA1a0hwapHiom0r/cKaoqr+27/XcrS5UwSMbQAAAABJRU5ErkJggg==
+[DeepWiki]: https://deepwiki.com/aperturerobotics/goscript
 
 ## Introduction
 

package/builtin/builtin.ts

@@ -731,8 +731,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
   kind: TypeKind.Struct
   methods: Set<string>
   ctor?: new (...args: any[]) => any
-  fields?: Set<string> // Field names for struct types
-  fieldTypes?: Record<string, TypeInfo | string> // Types for struct fields
+  fields: Record<string, TypeInfo | string> // Field names and types for struct fields
 }
 
 /**
@@ -870,13 +869,15 @@ export const registerStructType = (
   zeroValue: any,
   methods: Set<string>,
   ctor: new (...args: any[]) => any,
+  fields: Record<string, TypeInfo | string> = {},
 ): StructTypeInfo => {
   const typeInfo: StructTypeInfo = {
     name,
     kind: TypeKind.Struct,
     zeroValue,
     methods,
-    ctor: ctor,
+    ctor,
+    fields,
   }
   typeRegistry.set(name, typeInfo)
   return typeInfo
@@ -992,24 +993,35 @@ function matchesStructType(value: any, info: TypeInfo): boolean {
     return true
   }
 
-  if (info.fields && typeof value === 'object') {
-    // For struct type assertions, we need to check that the value has exactly
-    const descFields = Array.from(info.fields as Set<string>)
+  if (info.methods && typeof value === 'object' && value !== null) {
+    const allMethodsMatch = Array.from(info.methods).every(
+      (method) => typeof value[method] === 'function',
+    )
+    if (allMethodsMatch) {
+      return true
+    }
+  }
+
+  if (typeof value === 'object' && value !== null) {
+    const fieldNames = Object.keys(info.fields || {})
     const valueFields = Object.keys(value)
 
-    const condition1 = descFields.every((field) => field in value)
-    const condition2 = valueFields.length === descFields.length
-    const condition3 = valueFields.every((field) => descFields.includes(field))
+    const fieldsExist = fieldNames.every((field) => field in value)
+    const sameFieldCount = valueFields.length === fieldNames.length
+    const allFieldsInStruct = valueFields.every((field) =>
+      fieldNames.includes(field),
+    )
 
-    console.log('Struct field matching debug:', {
-      descFields,
-      valueFields,
-      allDescFieldsInValue: condition1,
-      sameFieldCount: condition2,
-      allValueFieldsInDesc: condition3,
-    })
+    if (fieldsExist && sameFieldCount && allFieldsInStruct) {
+      return Object.entries(info.fields).every(([fieldName, fieldType]) => {
+        return matchesType(
+          value[fieldName],
+          normalizeTypeInfo(fieldType as TypeInfo | string),
+        )
+      })
+    }
 
-    return condition1 && condition2 && condition3
+    return false
   }
 
   return false
@@ -1126,9 +1138,10 @@ function matchesArrayOrSliceType(value: any, info: TypeInfo): boolean {
  * @returns True if the value matches the pointer type, false otherwise.
  */
 function matchesPointerType(value: any, info: TypeInfo): boolean {
-  // For pointers, check if value is a Box (has a 'value' property)
+  // Allow null/undefined values to match pointer types to support nil pointer assertions
+  // This enables Go's nil pointer type assertions like `ptr, ok := i.(*SomeType)` to work correctly
   if (value === null || value === undefined) {
-    return false
+    return true
   }
 
   // Check if the value is a Box (has a 'value' property)
@@ -1153,9 +1166,18 @@ function matchesPointerType(value: any, info: TypeInfo): boolean {
  * @param info The function type info to match against.
  * @returns True if the value matches the function type, false otherwise.
  */
-function matchesFunctionType(value: any, info: TypeInfo): boolean {
-  // For functions, check if the value is a function
-  return typeof value === 'function'
+function matchesFunctionType(value: any, info: FunctionTypeInfo): boolean {
+  // First check if the value is a function
+  if (typeof value !== 'function') {
+    return false;
+  }
+  
+  // This is important for named function types
+  if (info.name && value.__goTypeName) {
+    return info.name === value.__goTypeName;
+  }
+  
+  return true;
 }
 
 /**
@@ -1165,17 +1187,56 @@ function matchesFunctionType(value: any, info: TypeInfo): boolean {
  * @param info The channel type info to match against.
  * @returns True if the value matches the channel type, false otherwise.
  */
-function matchesChannelType(value: any, info: TypeInfo): boolean {
-  return (
-    typeof value === 'object' &&
-    value !== null &&
-    'send' in value &&
-    'receive' in value &&
-    'close' in value &&
-    typeof value.send === 'function' &&
-    typeof value.receive === 'function' &&
-    typeof value.close === 'function'
-  )
+function matchesChannelType(value: any, info: ChannelTypeInfo): boolean {
+  // First check if it's a channel or channel reference
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+
+  // If it's a ChannelRef, get the underlying channel
+  let channel = value
+  let valueDirection = 'both'
+
+  if ('channel' in value && 'direction' in value) {
+    channel = value.channel
+    valueDirection = value.direction
+  }
+
+  // Check if it has channel methods
+  if (
+    !('send' in channel) ||
+    !('receive' in channel) ||
+    !('close' in channel) ||
+    typeof channel.send !== 'function' ||
+    typeof channel.receive !== 'function' ||
+    typeof channel.close !== 'function'
+  ) {
+    return false
+  }
+
+  if (info.elemType) {
+    if (
+      info.elemType === 'string' &&
+      'zeroValue' in channel &&
+      channel.zeroValue !== ''
+    ) {
+      return false
+    }
+
+    if (
+      info.elemType === 'number' &&
+      'zeroValue' in channel &&
+      typeof channel.zeroValue !== 'number'
+    ) {
+      return false
+    }
+  }
+
+  if (info.direction) {
+    return valueDirection === info.direction
+  }
+
+  return true
 }
 
 /**
@@ -1211,7 +1272,7 @@ function matchesType(value: any, info: TypeInfo): boolean {
       return matchesPointerType(value, info)
 
     case TypeKind.Function:
-      return matchesFunctionType(value, info)
+      return matchesFunctionType(value, info as FunctionTypeInfo)
 
     case TypeKind.Channel:
       return matchesChannelType(value, info)
@@ -1230,23 +1291,57 @@ export function typeAssert<T>(
 ): TypeAssertResult<T> {
   const normalizedType = normalizeTypeInfo(typeInfo)
 
+  if (isPointerTypeInfo(normalizedType) && value === null) {
+    return { value: null as unknown as T, ok: true }
+  }
+
+  if (
+    isStructTypeInfo(normalizedType) &&
+    normalizedType.methods &&
+    typeof value === 'object' &&
+    value !== null
+  ) {
+    // Check if the value implements all methods of the struct type
+    const allMethodsMatch = Array.from(normalizedType.methods).every(
+      (method) => typeof value[method] === 'function',
+    )
+
+    const hasAnyMethod = Array.from(normalizedType.methods).some(
+      (method) => typeof value[method] === 'function',
+    )
+
+    if (allMethodsMatch && hasAnyMethod && normalizedType.methods.size > 0) {
+      // For interface-to-concrete type assertions, we just need to check methods
+      return { value: value as T, ok: true }
+    }
+  }
+
   if (
     isStructTypeInfo(normalizedType) &&
     normalizedType.fields &&
     typeof value === 'object' &&
     value !== null
   ) {
-    const descFields = Array.from(normalizedType.fields as Set<string>)
+    const fieldNames = Object.keys(normalizedType.fields)
     const valueFields = Object.keys(value)
 
     // For struct type assertions, we need exact field matching
-    const structMatch =
-      descFields.length === valueFields.length &&
-      descFields.every((field: string) => field in value) &&
-      valueFields.every((field) => descFields.includes(field))
+    const structFieldsMatch =
+      fieldNames.length === valueFields.length &&
+      fieldNames.every((field: string) => field in value) &&
+      valueFields.every((field) => fieldNames.includes(field))
+
+    if (structFieldsMatch) {
+      const typesMatch = Object.entries(normalizedType.fields).every(
+        ([fieldName, fieldType]) => {
+          return matchesType(
+            value[fieldName],
+            normalizeTypeInfo(fieldType as TypeInfo | string),
+          )
+        },
+      )
 
-    if (structMatch) {
-      return { value: value as T, ok: true }
+      return { value: value as T, ok: typesMatch }
     } else {
       return { value: null as unknown as T, ok: false }
     }
@@ -1614,13 +1709,185 @@ class BufferedChannel<T> implements Channel<T> {
   }
 }
 
+/**
+ * Represents a reference to a channel with a specific direction.
+ */
+export interface ChannelRef<T> {
+  /**
+   * The underlying channel
+   */
+  channel: Channel<T>
+
+  /**
+   * The direction of this channel reference
+   */
+  direction: 'send' | 'receive' | 'both'
+
+  // Channel methods
+  send(value: T): Promise<void>
+  receive(): Promise<T>
+  receiveWithOk(): Promise<ChannelReceiveResult<T>>
+  close(): void
+  canSendNonBlocking(): boolean
+  canReceiveNonBlocking(): boolean
+  selectSend(value: T, id: number): Promise<SelectResult<boolean>>
+  selectReceive(id: number): Promise<SelectResult<T>>
+}
+
+/**
+ * A bidirectional channel reference.
+ */
+export class BidirectionalChannelRef<T> implements ChannelRef<T> {
+  direction: 'both' = 'both'
+
+  constructor(public channel: Channel<T>) {}
+
+  // Delegate all methods to the underlying channel
+  send(value: T): Promise<void> {
+    return this.channel.send(value)
+  }
+
+  receive(): Promise<T> {
+    return this.channel.receive()
+  }
+
+  receiveWithOk(): Promise<ChannelReceiveResult<T>> {
+    return this.channel.receiveWithOk()
+  }
+
+  close(): void {
+    this.channel.close()
+  }
+
+  canSendNonBlocking(): boolean {
+    return this.channel.canSendNonBlocking()
+  }
+
+  canReceiveNonBlocking(): boolean {
+    return this.channel.canReceiveNonBlocking()
+  }
+
+  selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
+    return this.channel.selectSend(value, id)
+  }
+
+  selectReceive(id: number): Promise<SelectResult<T>> {
+    return this.channel.selectReceive(id)
+  }
+}
+
+/**
+ * A send-only channel reference.
+ */
+export class SendOnlyChannelRef<T> implements ChannelRef<T> {
+  direction: 'send' = 'send'
+
+  constructor(public channel: Channel<T>) {}
+
+  // Allow send operations
+  send(value: T): Promise<void> {
+    return this.channel.send(value)
+  }
+
+  // Allow close operations
+  close(): void {
+    this.channel.close()
+  }
+
+  canSendNonBlocking(): boolean {
+    return this.channel.canSendNonBlocking()
+  }
+
+  selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
+    return this.channel.selectSend(value, id)
+  }
+
+  // Disallow receive operations
+  receive(): Promise<T> {
+    throw new Error('Cannot receive from send-only channel')
+  }
+
+  receiveWithOk(): Promise<ChannelReceiveResult<T>> {
+    throw new Error('Cannot receive from send-only channel')
+  }
+
+  canReceiveNonBlocking(): boolean {
+    return false
+  }
+
+  selectReceive(id: number): Promise<SelectResult<T>> {
+    throw new Error('Cannot receive from send-only channel')
+  }
+}
+
+/**
+ * A receive-only channel reference.
+ */
+export class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
+  direction: 'receive' = 'receive'
+
+  constructor(public channel: Channel<T>) {}
+
+  // Allow receive operations
+  receive(): Promise<T> {
+    return this.channel.receive()
+  }
+
+  receiveWithOk(): Promise<ChannelReceiveResult<T>> {
+    return this.channel.receiveWithOk()
+  }
+
+  canReceiveNonBlocking(): boolean {
+    return this.channel.canReceiveNonBlocking()
+  }
+
+  selectReceive(id: number): Promise<SelectResult<T>> {
+    return this.channel.selectReceive(id)
+  }
+
+  // Disallow send operations
+  send(value: T): Promise<void> {
+    throw new Error('Cannot send to receive-only channel')
+  }
+
+  // Disallow close operations
+  close(): void {
+    throw new Error('Cannot close receive-only channel')
+  }
+
+  canSendNonBlocking(): boolean {
+    return false
+  }
+
+  selectSend(value: T, id: number): Promise<SelectResult<boolean>> {
+    throw new Error('Cannot send to receive-only channel')
+  }
+}
+
+/**
+ * Creates a new channel reference with the specified direction.
+ */
+export function makeChannelRef<T>(
+  channel: Channel<T>,
+  direction: 'send' | 'receive' | 'both',
+): ChannelRef<T> {
+  switch (direction) {
+    case 'send':
+      return new SendOnlyChannelRef<T>(channel)
+    case 'receive':
+      return new ReceiveOnlyChannelRef<T>(channel)
+    default: // 'both'
+      return new BidirectionalChannelRef<T>(channel)
+  }
+}
+
 /**
  * Represents a case in a select statement.
  */
 export interface SelectCase<T> {
   id: number
   isSend: boolean // true for send, false for receive
-  channel: Channel<any> | null // Allow null
+  channel: Channel<any> | ChannelRef<any> | null // Allow null and ChannelRef
   value?: any // Value to send for send cases
   // Optional handlers for when this case is selected
   onSelected?: (result: SelectResult<T>) => Promise<void>
@@ -1736,13 +2003,24 @@ export async function selectStatement<T>(
  * Creates a new channel with the specified buffer size and zero value.
  * @param bufferSize The size of the channel buffer. If 0, creates an unbuffered channel.
  * @param zeroValue The zero value for the channel's element type.
- * @returns A new channel instance.
+ * @param direction Optional direction for the channel. Default is 'both' (bidirectional).
+ * @returns A new channel instance or channel reference.
  */
 export const makeChannel = <T>(
   bufferSize: number,
   zeroValue: T,
-): Channel<T> => {
-  return new BufferedChannel<T>(bufferSize, zeroValue)
+  direction: 'send' | 'receive' | 'both' = 'both',
+): Channel<T> | ChannelRef<T> => {
+  const channel = new BufferedChannel<T>(bufferSize, zeroValue)
+
+  // Wrap the channel with the appropriate ChannelRef based on direction
+  if (direction === 'send') {
+    return new SendOnlyChannelRef<T>(channel) as ChannelRef<T>
+  } else if (direction === 'receive') {
+    return new ReceiveOnlyChannelRef<T>(channel) as ChannelRef<T>
+  } else {
+    return channel
+  }
 }
 
 /**