goscript 0.0.16 → 0.0.18

package/compiler/writer.go

@@ -65,6 +65,15 @@ func (w *TSCodeWriter) WriteCommentLine(commentText string) {
 	}
 }
 
+// WriteCommentLinef writes a formatted comment as a // line.
+func (w *TSCodeWriter) WriteCommentLinef(format string, args ...any) {
+	commentText := fmt.Sprintf(format, args...)
+	lines := strings.SplitSeq(commentText, "\n")
+	for line := range lines {
+		w.WriteLinef("// %s", line)
+	}
+}
+
 // WriteCommentInline write a comment within /* */.
 func (w *TSCodeWriter) WriteCommentInline(commentText string) {
 	w.w.Write([]byte("/* "))       //nolint:errcheck
@@ -72,6 +81,11 @@ func (w *TSCodeWriter) WriteCommentInline(commentText string) {
 	w.w.Write([]byte(" */"))       //nolint:errcheck
 }
 
+// WriteCommentInlinef writes a formatted comment within /* */.
+func (w *TSCodeWriter) WriteCommentInlinef(format string, args ...any) {
+	w.WriteCommentInline(fmt.Sprintf(format, args...))
+}
+
 // WriteLiterally writes something to the output without processing
 func (w *TSCodeWriter) WriteLiterally(literal string) {
 	w.sectionWrittenFlag = true

package/dist/builtin/builtin.d.ts

@@ -177,8 +177,7 @@ export interface StructTypeInfo extends BaseTypeInfo {
     kind: TypeKind.Struct;
     methods: Set<string>;
     ctor?: new (...args: any[]) => any;
-    fields?: Set<string>;
-    fieldTypes?: Record<string, TypeInfo | string>;
+    fields: Record<string, TypeInfo | string>;
 }
 /**
  * Type information for interface types
@@ -261,7 +260,7 @@ export declare function isChannelTypeInfo(info: TypeInfo): info is ChannelTypeIn
  * @param ctor Constructor for the struct.
  * @returns The struct type information object.
  */
-export declare const registerStructType: (name: string, zeroValue: any, methods: Set<string>, ctor: new (...args: any[]) => any) => StructTypeInfo;
+export declare const registerStructType: (name: string, zeroValue: any, methods: Set<string>, ctor: new (...args: any[]) => any, fields?: Record<string, TypeInfo | string>) => StructTypeInfo;
 /**
  * Registers an interface type with the runtime type system.
  *
@@ -350,13 +349,86 @@ export interface Channel<T> {
      */
     canSendNonBlocking(): boolean;
 }
+/**
+ * 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';
+    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 declare class BidirectionalChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'both';
+    constructor(channel: Channel<T>);
+    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 send-only channel reference.
+ */
+export declare class SendOnlyChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'send';
+    constructor(channel: Channel<T>);
+    send(value: T): Promise<void>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    canReceiveNonBlocking(): boolean;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+}
+/**
+ * A receive-only channel reference.
+ */
+export declare class ReceiveOnlyChannelRef<T> implements ChannelRef<T> {
+    channel: Channel<T>;
+    direction: 'receive';
+    constructor(channel: Channel<T>);
+    receive(): Promise<T>;
+    receiveWithOk(): Promise<ChannelReceiveResult<T>>;
+    canReceiveNonBlocking(): boolean;
+    selectReceive(id: number): Promise<SelectResult<T>>;
+    send(value: T): Promise<void>;
+    close(): void;
+    canSendNonBlocking(): boolean;
+    selectSend(value: T, id: number): Promise<SelectResult<boolean>>;
+}
+/**
+ * Creates a new channel reference with the specified direction.
+ */
+export declare function makeChannelRef<T>(channel: Channel<T>, direction: 'send' | 'receive' | 'both'): ChannelRef<T>;
 /**
  * Represents a case in a select statement.
  */
 export interface SelectCase<T> {
     id: number;
     isSend: boolean;
-    channel: Channel<any> | null;
+    channel: Channel<any> | ChannelRef<any> | null;
     value?: any;
     onSelected?: (result: SelectResult<T>) => Promise<void>;
 }
@@ -373,9 +445,10 @@ export declare function selectStatement<T>(cases: SelectCase<T>[], hasDefault?:
  * 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 declare const makeChannel: <T>(bufferSize: number, zeroValue: T) => Channel<T>;
+export declare const makeChannel: <T>(bufferSize: number, zeroValue: T, direction?: "send" | "receive" | "both") => Channel<T> | ChannelRef<T>;
 /**
  * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.
  * Functions added via `defer` are executed in LIFO order when the stack is disposed.

package/dist/builtin/builtin.js

@@ -585,13 +585,14 @@ const typeRegistry = new Map();
  * @param ctor Constructor for the struct.
  * @returns The struct type information object.
  */
-export const registerStructType = (name, zeroValue, methods, ctor) => {
+export const registerStructType = (name, zeroValue, methods, ctor, fields = {}) => {
     const typeInfo = {
         name,
         kind: TypeKind.Struct,
         zeroValue,
         methods,
-        ctor: ctor,
+        ctor,
+        fields,
     };
     typeRegistry.set(name, typeInfo);
     return typeInfo;
@@ -689,21 +690,24 @@ function matchesStructType(value, info) {
     if (info.ctor && value instanceof info.ctor) {
         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);
+    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));
-        console.log('Struct field matching debug:', {
-            descFields,
-            valueFields,
-            allDescFieldsInValue: condition1,
-            sameFieldCount: condition2,
-            allValueFieldsInDesc: condition3,
-        });
-        return condition1 && condition2 && condition3;
+        const fieldsExist = fieldNames.every((field) => field in value);
+        const sameFieldCount = valueFields.length === fieldNames.length;
+        const allFieldsInStruct = valueFields.every((field) => fieldNames.includes(field));
+        if (fieldsExist && sameFieldCount && allFieldsInStruct) {
+            return Object.entries(info.fields).every(([fieldName, fieldType]) => {
+                return matchesType(value[fieldName], normalizeTypeInfo(fieldType));
+            });
+        }
+        return false;
     }
     return false;
 }
@@ -796,9 +800,10 @@ function matchesArrayOrSliceType(value, info) {
  * @returns True if the value matches the pointer type, false otherwise.
  */
 function matchesPointerType(value, info) {
-    // 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)
     if (typeof value !== 'object' || !('value' in value)) {
@@ -820,8 +825,15 @@ function matchesPointerType(value, info) {
  * @returns True if the value matches the function type, false otherwise.
  */
 function matchesFunctionType(value, info) {
-    // For functions, check if the value is a function
-    return typeof value === 'function';
+    // 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;
 }
 /**
  * Checks if a value matches a channel type info.
@@ -831,14 +843,42 @@ function matchesFunctionType(value, info) {
  * @returns True if the value matches the channel type, false otherwise.
  */
 function matchesChannelType(value, info) {
-    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');
+    // 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;
 }
 /**
  * Checks if a value matches a type info.
@@ -876,18 +916,36 @@ function matchesType(value, info) {
 }
 export function typeAssert(value, typeInfo) {
     const normalizedType = normalizeTypeInfo(typeInfo);
+    if (isPointerTypeInfo(normalizedType) && value === null) {
+        return { value: null, 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, ok: true };
+        }
+    }
     if (isStructTypeInfo(normalizedType) &&
         normalizedType.fields &&
         typeof value === 'object' &&
         value !== null) {
-        const descFields = Array.from(normalizedType.fields);
+        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) => field in value) &&
-            valueFields.every((field) => descFields.includes(field));
-        if (structMatch) {
-            return { value: value, ok: true };
+        const structFieldsMatch = fieldNames.length === valueFields.length &&
+            fieldNames.every((field) => 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));
+            });
+            return { value: value, ok: typesMatch };
         }
         else {
             return { value: null, ok: false };
@@ -1124,6 +1182,128 @@ class BufferedChannel {
         return !this.closed && this.buffer.length < this.capacity;
     }
 }
+/**
+ * A bidirectional channel reference.
+ */
+export class BidirectionalChannelRef {
+    channel;
+    direction = 'both';
+    constructor(channel) {
+        this.channel = channel;
+    }
+    // Delegate all methods to the underlying channel
+    send(value) {
+        return this.channel.send(value);
+    }
+    receive() {
+        return this.channel.receive();
+    }
+    receiveWithOk() {
+        return this.channel.receiveWithOk();
+    }
+    close() {
+        this.channel.close();
+    }
+    canSendNonBlocking() {
+        return this.channel.canSendNonBlocking();
+    }
+    canReceiveNonBlocking() {
+        return this.channel.canReceiveNonBlocking();
+    }
+    selectSend(value, id) {
+        return this.channel.selectSend(value, id);
+    }
+    selectReceive(id) {
+        return this.channel.selectReceive(id);
+    }
+}
+/**
+ * A send-only channel reference.
+ */
+export class SendOnlyChannelRef {
+    channel;
+    direction = 'send';
+    constructor(channel) {
+        this.channel = channel;
+    }
+    // Allow send operations
+    send(value) {
+        return this.channel.send(value);
+    }
+    // Allow close operations
+    close() {
+        this.channel.close();
+    }
+    canSendNonBlocking() {
+        return this.channel.canSendNonBlocking();
+    }
+    selectSend(value, id) {
+        return this.channel.selectSend(value, id);
+    }
+    // Disallow receive operations
+    receive() {
+        throw new Error('Cannot receive from send-only channel');
+    }
+    receiveWithOk() {
+        throw new Error('Cannot receive from send-only channel');
+    }
+    canReceiveNonBlocking() {
+        return false;
+    }
+    selectReceive(id) {
+        throw new Error('Cannot receive from send-only channel');
+    }
+}
+/**
+ * A receive-only channel reference.
+ */
+export class ReceiveOnlyChannelRef {
+    channel;
+    direction = 'receive';
+    constructor(channel) {
+        this.channel = channel;
+    }
+    // Allow receive operations
+    receive() {
+        return this.channel.receive();
+    }
+    receiveWithOk() {
+        return this.channel.receiveWithOk();
+    }
+    canReceiveNonBlocking() {
+        return this.channel.canReceiveNonBlocking();
+    }
+    selectReceive(id) {
+        return this.channel.selectReceive(id);
+    }
+    // Disallow send operations
+    send(value) {
+        throw new Error('Cannot send to receive-only channel');
+    }
+    // Disallow close operations
+    close() {
+        throw new Error('Cannot close receive-only channel');
+    }
+    canSendNonBlocking() {
+        return false;
+    }
+    selectSend(value, id) {
+        throw new Error('Cannot send to receive-only channel');
+    }
+}
+/**
+ * Creates a new channel reference with the specified direction.
+ */
+export function makeChannelRef(channel, direction) {
+    switch (direction) {
+        case 'send':
+            return new SendOnlyChannelRef(channel);
+        case 'receive':
+            return new ReceiveOnlyChannelRef(channel);
+        default: // 'both'
+            return new BidirectionalChannelRef(channel);
+    }
+}
 /**
  * Helper for 'select' statements. Takes an array of select cases
  * and resolves when one of them completes, following Go's select rules.
@@ -1224,10 +1404,21 @@ export async function selectStatement(cases, hasDefault = false) {
  * 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 = (bufferSize, zeroValue) => {
-    return new BufferedChannel(bufferSize, zeroValue);
+export const makeChannel = (bufferSize, zeroValue, direction = 'both') => {
+    const channel = new BufferedChannel(bufferSize, zeroValue);
+    // Wrap the channel with the appropriate ChannelRef based on direction
+    if (direction === 'send') {
+        return new SendOnlyChannelRef(channel);
+    }
+    else if (direction === 'receive') {
+        return new ReceiveOnlyChannelRef(channel);
+    }
+    else {
+        return channel;
+    }
 };
 /**
  * DisposableStack manages synchronous disposable resources, mimicking Go's defer behavior.